soliplex 0.78.1__tar.gz → 0.78.2__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "soliplex"
-version = "0.78.1"
+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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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

{soliplex-0.78.1 → soliplex-0.78.2}/src/soliplex/views/sandbox_workdirs.py

@@ -1,10 +1,14 @@
+import os
 import pathlib
+import stat
+import urllib.parse as url_parse
 
 import fastapi
 import pydantic
 from fastapi import responses
 
-from soliplex import authn as authn_package
+from soliplex import agui
+from soliplex import authn
 from soliplex import authz
 from soliplex import installation
 from soliplex import loggers
@@ -16,11 +20,20 @@ from soliplex.views import util as soliplex_views_util
 router = fastapi.APIRouter(tags=["uploads"])
 
 depend_the_installation = installation.depend_the_installation
+depend_the_threads = agui.depend_the_threads
 depend_the_room_authz = views.depend_the_room_authz_policy
 depend_the_user_claims = views.depend_the_user_claims
 depend_the_logger = views.depend_the_logger
 
 
+CHUNKSIZE = 2**16  # 64k
+
+# DO NOT SIMPLIFY HERE:
+# This is the RFC 5987 extended-parameter syntax for a
+# 'Content-Disposition' header value using 'attachment'.
+ATTACHMENT_PREFIX = "attachment; filename*=UTF-8''"
+
+
 @soliplex_views_util.logfire_span(
     "GET /v1/workdirs/{room_id}/thread/{thread_id}/{run_id}",
 )
@@ -31,8 +44,9 @@ async def get_workdirs_room_thread_run(
     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_package.UserClaims = depend_the_user_claims,
+    the_user_claims: authn.UserClaims = depend_the_user_claims,
     the_logger: loggers.LogWrapper = depend_the_logger,
 ) -> models.RunWorkdirFiles:
     """Return a list of files uploaded to the thread"""
@@ -41,9 +55,12 @@ async def get_workdirs_room_thread_run(
 
     the_logger.debug(loggers.WORKDIRS_GET_ROOM_THREAD_RUN)
 
-    _room_config = await soliplex_views_agui._check_user_in_room(
+    await soliplex_views_agui._check_thread_ownership(
         room_id=room_id,
+        thread_id=thread_id,
+        run_id=run_id,
         the_installation=the_installation,
+        the_threads=the_threads,
         the_room_authz=the_room_authz,
         the_user_claims=the_user_claims,
         the_logger=the_logger,
@@ -62,7 +79,7 @@ async def get_workdirs_room_thread_run(
 
     if run_dir.is_dir():
         for file_or_sub in run_dir.glob("*"):
-            if file_or_sub.is_file():
+            if not file_or_sub.is_symlink() and file_or_sub.is_file():
                 filename = file_or_sub.name
                 filename_urls[filename] = request.url_for(
                     # View function name, not the route path.
@@ -87,13 +104,48 @@ async def get_workdirs_room_thread_run(
     )
 
 
+def _open_no_symlinks(file_path: pathlib.Path):
+    """Return a streaming generator for 'file_path'
+
+    First ensure that it is a regular file (no symlinks, etc.)
+    """
+    not_found = f"No workdir file: {file_path.name}"
+
+    try:
+        fd = os.open(
+            file_path,
+            os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | os.O_CLOEXEC,
+        )
+    except OSError:  # ELOOP for a symlink, ENOENT, EACCES
+        raise fastapi.HTTPException(
+            status_code=404,
+            detail=not_found,
+        ) from None
+
+    st = os.fstat(fd)
+    if not stat.S_ISREG(st.st_mode):  # directory, FIFO, device, socket
+        os.close(fd)
+        raise fastapi.HTTPException(status_code=404, detail=not_found)
+
+    def _stream():  # now owns the fd
+        with os.fdopen(fd, "rb") as fh:
+            while chunk := fh.read(CHUNKSIZE):
+                yield chunk
+
+    return _stream, st.st_size
+
+
+def _disposition(file_path: pathlib.Path) -> str:
+    attachment_name = url_parse.quote(file_path.name, safe="")
+    return f"{ATTACHMENT_PREFIX}{attachment_name}"
+
+
 @soliplex_views_util.logfire_span(
     "GET "
     "/v1/workdirs/{room_id}/thread/{thread_id}/run/{run_id}/file/{filename}"
 )
 @router.get(
     "/v1/workdirs/{room_id}/thread/{thread_id}/run/{run_id}/file/{filename}",
-    response_class=responses.FileResponse,
 )
 async def get_workdirs_room_thread_run_filename(
     room_id: str,
@@ -101,19 +153,28 @@ async def get_workdirs_room_thread_run_filename(
     run_id: pydantic.UUID4,
     filename: str,
     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_package.UserClaims = depend_the_user_claims,
+    the_user_claims: authn.UserClaims = depend_the_user_claims,
     the_logger: loggers.LogWrapper = depend_the_logger,
-) -> str:  # file path, converted to file response by FastAPI
-    """Return a list of files uploaded to the thread"""
+) -> responses.StreamingResponse:
+    """Return a file uploaded to the thread.
+
+    In order to prevent an agent-created symlink from exposing a file
+    not in the workdir, this view returns a streaming response, rather
+    than using `fastapi`s 'FileResponse-from-filename' affordance.
+    """
     thread_id = str(thread_id)
     run_id = str(run_id)
 
     the_logger.debug(loggers.WORKDIRS_GET_ROOM_THREAD_RUN_FILE)
 
-    _room_config = await soliplex_views_agui._check_user_in_room(
+    await soliplex_views_agui._check_thread_ownership(
         room_id=room_id,
+        thread_id=thread_id,
+        run_id=run_id,
         the_installation=the_installation,
+        the_threads=the_threads,
         the_room_authz=the_room_authz,
         the_user_claims=the_user_claims,
         the_logger=the_logger,
@@ -130,10 +191,23 @@ async def get_workdirs_room_thread_run_filename(
     run_dir = pathlib.Path(workdirs_path) / room_id / thread_id / run_id
 
     file_path = run_dir / filename
-    if not file_path.is_file():
-        raise fastapi.HTTPException(
-            status_code=404,
-            detail=f"No workdir file: {filename}",
-        )
 
-    return str(file_path)
+    streamer, size = _open_no_symlinks(file_path)
+
+    stream = streamer()
+
+    # Declare one fixed, inert type rather than guessing from the
+    # filename as 'FileResponse' did: the name is chosen by
+    # model-authored code, so a guess would hand the browser a
+    # content type derived from untrusted input. Together with the
+    # 'attachment' disposition and 'nosniff', this makes the browser
+    # download the file and never interpret it.
+    return responses.StreamingResponse(
+        stream,
+        media_type="application/octet-stream",
+        headers={
+            "content-length": str(size),
+            "content-disposition": _disposition(file_path),
+            "x-content-type-options": "nosniff",
+        },
+    )

{soliplex-0.78.1 → soliplex-0.78.2}/src/soliplex/views/thread_file_uploads.py

@@ -5,7 +5,7 @@ import pydantic
 from fastapi import responses
 
 from soliplex import agui
-from soliplex import authn as authn_package
+from soliplex import authn
 from soliplex import authz
 from soliplex import installation
 from soliplex import loggers
@@ -32,18 +32,21 @@ async def get_uploads_room_id_thread_thread_id(
     room_id: str,
     thread_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_package.UserClaims = depend_the_user_claims,
+    the_user_claims: authn.UserClaims = depend_the_user_claims,
     the_logger: loggers.LogWrapper = depend_the_logger,
-) -> models.RoomUploads:
+) -> models.ThreadUploads:
     """Return a list of files uploaded to the thread"""
     thread_id = str(thread_id)
 
     the_logger.debug(loggers.UPLOADS_GET_ROOM_THREAD)
 
-    _room_config = await soliplex_views_agui._check_user_in_room(
+    await soliplex_views_agui._check_thread_ownership(
         room_id=room_id,
+        thread_id=thread_id,
         the_installation=the_installation,
+        the_threads=the_threads,
         the_room_authz=the_room_authz,
         the_user_claims=the_user_claims,
         the_logger=the_logger,
@@ -97,18 +100,28 @@ async def get_uploads_room_id_thread_thread_id_filename(
     thread_id: pydantic.UUID4,
     filename: str,
     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_package.UserClaims = depend_the_user_claims,
+    the_user_claims: authn.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 thread uploads directory
+
+    Unlike sandbox workdir files, which are created by a possibly-
+    hallucinating or mischievous agent, files in the thread-uploads tree
+    are durable.  The operator may choose to add a symlink into a particular
+    thread's directory to share a large dataset, without requiring that
+    the user download it from somewhere and then re-upload it here.
+    """
     thread_id = str(thread_id)
 
     the_logger.debug(loggers.UPLOADS_GET_ROOM_THREAD_FILE)
 
-    _room_config = await soliplex_views_agui._check_user_in_room(
+    await soliplex_views_agui._check_thread_ownership(
         room_id=room_id,
+        thread_id=thread_id,
         the_installation=the_installation,
+        the_threads=the_threads,
         the_room_authz=the_room_authz,
         the_user_claims=the_user_claims,
         the_logger=the_logger,
@@ -127,7 +140,7 @@ async def get_uploads_room_id_thread_thread_id_filename(
     if not thread_dir.is_dir():
         raise fastapi.HTTPException(
             status_code=404,
-            detail="No uploads in thread: {thread_id}",
+            detail=f"No uploads in thread: {thread_id}",
         )
 
     file_path = thread_dir / filename
@@ -152,7 +165,7 @@ async def post_uploads_room_id_thread_thread_id(
     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_package.UserClaims = depend_the_user_claims,
+    the_user_claims: authn.UserClaims = depend_the_user_claims,
     the_logger: loggers.LogWrapper = depend_the_logger,
 ) -> fastapi.Response:
     """Upload a file for a thread within the given room
@@ -164,16 +177,17 @@ async def post_uploads_room_id_thread_thread_id(
 
     the_logger.debug(loggers.UPLOADS_POST_ROOM_THREAD)
 
-    user_name = the_user_claims.get("preferred_username", "<unknown>")
-    _room_config = await soliplex_views_agui._check_user_in_room(
+    room_config = await soliplex_views_agui._check_thread_ownership(
         room_id=room_id,
+        thread_id=thread_id,
         the_installation=the_installation,
+        the_threads=the_threads,
         the_room_authz=the_room_authz,
         the_user_claims=the_user_claims,
         the_logger=the_logger,
     )
 
-    if not _room_config.has_sandbox:
+    if not room_config.has_sandbox:
         raise fastapi.HTTPException(
             status_code=405,
             detail="Sandbox not configured",
@@ -189,18 +203,6 @@ async def post_uploads_room_id_thread_thread_id(
             headers={"Allow": "GET"},
         )
 
-    try:
-        await the_threads.get_thread(
-            user_name=user_name,
-            room_id=room_id,
-            thread_id=thread_id,
-        )
-    except agui.AGUI_Exception as exc:
-        raise fastapi.HTTPException(
-            status_code=exc.status_code,
-            detail=exc.args,
-        ) from None
-
     thread_dir = pathlib.Path(uploads_path) / thread_id
     thread_dir.mkdir(parents=True, exist_ok=True)
     stripped_filename = pathlib.Path(upload_file.filename).name

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

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