fix(chat): fix mcpcnf id & checking thread existence when working with subresources

Author: adi-wan-askui

src/askui/chat/api/mcp_configs/models.py

@@ -40,7 +40,7 @@ class McpConfig(McpConfigBase, Resource):
     @classmethod
     def create(cls, params: McpConfigCreateParams) -> "McpConfig":
         return cls(
-            id=generate_time_ordered_id("mcp_config"),
+            id=generate_time_ordered_id("mcpcnf"),
             created_at=now(),
             **params.model_dump(),
         )

src/askui/chat/api/messages/router.py

@@ -5,6 +5,8 @@
 from askui.chat.api.messages.models import Message, MessageCreateParams
 from askui.chat.api.messages.service import MessageService
 from askui.chat.api.models import MessageId, ThreadId
+from askui.chat.api.threads.dependencies import ThreadFacadeDep
+from askui.chat.api.threads.facade import ThreadFacade
 from askui.utils.api_utils import ListQuery, ListResponse
 
 router = APIRouter(prefix="/threads/{thread_id}/messages", tags=["messages"])
@@ -14,18 +16,18 @@
 def list_messages(
     thread_id: ThreadId,
     query: ListQuery = ListQueryDep,
-    message_service: MessageService = MessageServiceDep,
+    thread_facade: ThreadFacade = ThreadFacadeDep,
 ) -> ListResponse[Message]:
-    return message_service.list_(thread_id, query=query)
+    return thread_facade.list_messages(thread_id, query=query)
 
 
 @router.post("", status_code=status.HTTP_201_CREATED)
 async def create_message(
     thread_id: ThreadId,
     params: MessageCreateParams,
-    message_service: MessageService = MessageServiceDep,
+    thread_facade: ThreadFacade = ThreadFacadeDep,
 ) -> Message:
-    return message_service.create(thread_id=thread_id, params=params)
+    return thread_facade.create_message(thread_id=thread_id, params=params)
 
 
 @router.get("/{message_id}")

src/askui/chat/api/runs/router.py

@@ -8,6 +8,8 @@
 from askui.chat.api.dependencies import ListQueryDep
 from askui.chat.api.models import RunId, ThreadId
 from askui.chat.api.runs.models import RunCreateParams
+from askui.chat.api.threads.dependencies import ThreadFacadeDep
+from askui.chat.api.threads.facade import ThreadFacade
 from askui.utils.api_utils import ListQuery, ListResponse
 
 from .dependencies import RunServiceDep
@@ -22,10 +24,10 @@ async def create_run(
     thread_id: Annotated[ThreadId, Path(...)],
     params: RunCreateParams,
     background_tasks: BackgroundTasks,
-    run_service: RunService = RunServiceDep,
+    thread_facade: ThreadFacade = ThreadFacadeDep,
 ) -> Response:
     stream = params.stream
-    run, async_generator = await run_service.create(thread_id, params)
+    run, async_generator = await thread_facade.create_run(thread_id, params)
     if stream:
 
         async def sse_event_stream() -> AsyncGenerator[str, None]:
@@ -64,9 +66,9 @@ def retrieve_run(
 def list_runs(
     thread_id: Annotated[ThreadId, Path(...)],
     query: ListQuery = ListQueryDep,
-    run_service: RunService = RunServiceDep,
+    thread_facade: ThreadFacade = ThreadFacadeDep,
 ) -> ListResponse[Run]:
-    return run_service.list_(thread_id, query=query)
+    return thread_facade.list_runs(thread_id, query=query)
 
 
 @router.post("/{run_id}/cancel")

src/askui/chat/api/threads/dependencies.py

@@ -7,6 +7,7 @@
 from askui.chat.api.messages.service import MessageService
 from askui.chat.api.runs.dependencies import RunServiceDep
 from askui.chat.api.runs.service import RunService
+from askui.chat.api.threads.facade import ThreadFacade
 from askui.chat.api.threads.service import ThreadService
 
 
@@ -24,3 +25,18 @@ def get_thread_service(
 
 
 ThreadServiceDep = Depends(get_thread_service)
+
+
+def get_thread_facade(
+    thread_service: ThreadService = ThreadServiceDep,
+    message_service: MessageService = MessageServiceDep,
+    run_service: RunService = RunServiceDep,
+) -> ThreadFacade:
+    return ThreadFacade(
+        thread_service=thread_service,
+        message_service=message_service,
+        run_service=run_service,
+    )
+
+
+ThreadFacadeDep = Depends(get_thread_facade)

src/askui/chat/api/threads/facade.py

@@ -0,0 +1,56 @@
+from collections.abc import AsyncGenerator
+
+from askui.chat.api.messages.models import Message, MessageCreateParams
+from askui.chat.api.messages.service import MessageService
+from askui.chat.api.models import ThreadId
+from askui.chat.api.runs.models import Run, RunCreateParams
+from askui.chat.api.runs.runner.events.events import Events
+from askui.chat.api.runs.service import RunService
+from askui.chat.api.threads.service import ThreadService
+from askui.utils.api_utils import ListQuery, ListResponse
+
+
+class ThreadFacade:
+    """
+    Facade service that coordinates operations across threads, messages, and runs.
+    """
+
+    def __init__(
+        self,
+        thread_service: ThreadService,
+        message_service: MessageService,
+        run_service: RunService,
+    ) -> None:
+        self._thread_service = thread_service
+        self._message_service = message_service
+        self._run_service = run_service
+
+    def _ensure_thread_exists(self, thread_id: ThreadId) -> None:
+        """Validate that a thread exists before allowing operations on it."""
+        self._thread_service.retrieve(thread_id)
+
+    def create_message(
+        self, thread_id: ThreadId, params: MessageCreateParams
+    ) -> Message:
+        """Create a message, ensuring the thread exists first."""
+        self._ensure_thread_exists(thread_id)
+        return self._message_service.create(thread_id, params)
+
+    async def create_run(
+        self, thread_id: ThreadId, params: RunCreateParams
+    ) -> tuple[Run, AsyncGenerator[Events, None]]:
+        """Create a run, ensuring the thread exists first."""
+        self._ensure_thread_exists(thread_id)
+        return await self._run_service.create(thread_id, params)
+
+    def list_messages(
+        self, thread_id: ThreadId, query: ListQuery
+    ) -> ListResponse[Message]:
+        """List messages, ensuring the thread exists first."""
+        self._ensure_thread_exists(thread_id)
+        return self._message_service.list_(thread_id, query)
+
+    def list_runs(self, thread_id: ThreadId, query: ListQuery) -> ListResponse[Run]:
+        """List runs, ensuring the thread exists first."""
+        self._ensure_thread_exists(thread_id)
+        return self._run_service.list_(thread_id, query)