spaik-sdk 0.6.2__py3-none-any.whl

spaik_sdk/server/api/routers/file_router_factory.py

@@ -0,0 +1,111 @@
+from typing import Optional
+
+from fastapi import APIRouter, Depends, File, HTTPException, Request, UploadFile
+from fastapi.responses import Response
+from pydantic import BaseModel
+
+from spaik_sdk.attachments.storage.base_file_storage import BaseFileStorage
+from spaik_sdk.server.authorization.base_authorizer import BaseAuthorizer
+from spaik_sdk.server.authorization.base_user import BaseUser
+from spaik_sdk.utils.init_logger import init_logger
+
+logger = init_logger(__name__)
+
+
+class FileUploadResponse(BaseModel):
+    file_id: str
+    mime_type: str
+    filename: Optional[str]
+    size_bytes: int
+
+
+class FileDeleteResponse(BaseModel):
+    success: bool
+
+
+class FileRouterFactory:
+    def __init__(
+        self,
+        file_storage: BaseFileStorage,
+        authorizer: Optional[BaseAuthorizer[BaseUser]] = None,
+    ):
+        self.file_storage = file_storage
+        self.authorizer = authorizer
+
+    def create_router(self, prefix: str = "/files") -> APIRouter:
+        router = APIRouter(prefix=prefix, tags=["files"])
+
+        async def get_current_user(request: Request) -> BaseUser:
+            if self.authorizer is None:
+                return BaseUser("anonymous")
+            user = await self.authorizer.get_user(request)
+            if not user:
+                raise HTTPException(status_code=401, detail="Unauthorized")
+            return user
+
+        @router.post("", response_model=FileUploadResponse)
+        async def upload_file(
+            file: UploadFile = File(...),
+            user: BaseUser = Depends(get_current_user),
+        ):
+            if self.authorizer and not await self.authorizer.can_upload_file(user):
+                raise HTTPException(status_code=403, detail="Not authorized to upload files")
+
+            content = await file.read()
+            mime_type = file.content_type or "application/octet-stream"
+
+            metadata = await self.file_storage.store(
+                data=content,
+                mime_type=mime_type,
+                owner_id=user.get_id(),
+                filename=file.filename,
+            )
+
+            return FileUploadResponse(
+                file_id=metadata.file_id,
+                mime_type=metadata.mime_type,
+                filename=metadata.filename,
+                size_bytes=metadata.size_bytes,
+            )
+
+        @router.get("/{file_id}")
+        async def download_file(
+            file_id: str,
+            user: BaseUser = Depends(get_current_user),
+        ):
+            metadata = await self.file_storage.get_metadata(file_id)
+            if metadata is None:
+                raise HTTPException(status_code=404, detail="File not found")
+
+            if self.authorizer and not await self.authorizer.can_read_file(user, metadata):
+                raise HTTPException(status_code=403, detail="Not authorized to access this file")
+
+            try:
+                content, _ = await self.file_storage.retrieve(file_id)
+            except FileNotFoundError:
+                raise HTTPException(status_code=404, detail="File not found")
+
+            return Response(
+                content=content,
+                media_type=metadata.mime_type,
+                headers={
+                    "Content-Disposition": f'inline; filename="{metadata.filename or file_id}"',
+                },
+            )
+
+        @router.delete("/{file_id}", response_model=FileDeleteResponse)
+        async def delete_file(
+            file_id: str,
+            user: BaseUser = Depends(get_current_user),
+        ):
+            metadata = await self.file_storage.get_metadata(file_id)
+            if metadata is None:
+                raise HTTPException(status_code=404, detail="File not found")
+
+            if self.authorizer and not await self.authorizer.can_delete_file(user, metadata):
+                raise HTTPException(status_code=403, detail="Not authorized to delete this file")
+
+            success = await self.file_storage.delete(file_id)
+            return FileDeleteResponse(success=success)
+
+        return router

spaik_sdk/server/api/routers/thread_router_factory.py

@@ -0,0 +1,284 @@
+import json
+import time
+import uuid
+from collections.abc import Callable
+from typing import Awaitable, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from fastapi.responses import StreamingResponse
+
+from spaik_sdk.server.api.streaming.streaming_negotiator import StreamingNegotiator
+from spaik_sdk.server.authorization.base_authorizer import BaseAuthorizer
+from spaik_sdk.server.authorization.base_user import BaseUser
+from spaik_sdk.server.authorization.dummy_authorizer import DummyAuthorizer
+from spaik_sdk.server.job_processor.thread_job_processor import ThreadJobProcessor
+from spaik_sdk.server.pubsub.cancellation_publisher import CancellationPublisher
+from spaik_sdk.server.pubsub.cancellation_subscriber import CancellationSubscriber
+from spaik_sdk.server.queue.agent_job_queue import AgentJob, AgentJobQueue, JobType
+from spaik_sdk.server.services.thread_converters import ThreadConverters
+from spaik_sdk.server.services.thread_models import (
+    CreateMessageRequest,
+    CreateThreadRequest,
+    ListThreadsResponse,
+    MessageResponse,
+    ThreadResponse,
+)
+from spaik_sdk.server.services.thread_service import ThreadService
+from spaik_sdk.server.storage.thread_filter import ThreadFilter
+from spaik_sdk.thread.models import MessageAddedEvent, MessageBlock, MessageBlockType, ThreadMessage
+from spaik_sdk.thread.thread_container import ThreadContainer
+from spaik_sdk.utils.init_logger import init_logger
+
+logger = init_logger(__name__)
+
+
+class ThreadRouterFactory:
+    def __init__(
+        self,
+        service: ThreadService,
+        authorizer: Optional[BaseAuthorizer[BaseUser]] = None,
+        streaming_negotiator: Optional[StreamingNegotiator] = None,
+        job_queue: Optional[AgentJobQueue] = None,
+        thread_job_processor: Optional[ThreadJobProcessor] = None,
+        cancellation_subscriber_provider: Optional[Callable[[str], Awaitable[CancellationSubscriber]]] = None,
+        cancellation_publisher: Optional[CancellationPublisher] = None,
+    ):
+        self.authorizer = authorizer or DummyAuthorizer()
+        self.service = service
+        self.streaming_negotiator = streaming_negotiator
+        self.job_queue = job_queue
+        self.thread_job_processor = thread_job_processor
+        self.cancellation_subscriber_provider = cancellation_subscriber_provider
+        self.cancellation_publisher = cancellation_publisher
+
+    def create_router(self, prefix: str = "/threads") -> APIRouter:
+        router = APIRouter(prefix=prefix, tags=["threads"])
+
+        async def get_current_user(request: Request) -> BaseUser:
+            user = await self.authorizer.get_user(request)
+            if not user:
+                raise HTTPException(status_code=401, detail="Unauthorized")
+            return user
+
+        @router.post("", response_model=ThreadResponse)
+        async def create_thread(request: CreateThreadRequest, user: BaseUser = Depends(get_current_user)):
+            """Create a new thread"""
+            if not await self.authorizer.can_create_thread(user):
+                raise HTTPException(status_code=403, detail="Access denied")
+            thread_container = ThreadContainer()  # TODO giving no args (eg system prompt) might cause issues
+            created_thread = await self.service.create_thread(thread_container)
+            return ThreadConverters.thread_model_to_response(created_thread)
+
+        @router.get("/{thread_id}", response_model=ThreadResponse)
+        async def get_thread(thread_id: str, user: BaseUser = Depends(get_current_user)):
+            """Get thread by ID"""
+
+            thread = await self.service.get_thread(thread_id)
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+            if not await self.authorizer.can_read_thread(user, thread):
+                raise HTTPException(status_code=403, detail="Access denied")
+
+            return ThreadConverters.thread_model_to_response(thread)
+
+        @router.delete("/{thread_id}")
+        async def delete_thread(thread_id: str, user: BaseUser = Depends(get_current_user)):
+            """Delete thread"""
+            thread = await self.service.get_thread(thread_id)
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+            if not await self.authorizer.can_delete_thread(user, thread):
+                raise HTTPException(status_code=403, detail="Access denied")
+
+            await self.service.delete_thread(thread_id)
+            return {"message": "Thread deleted successfully"}
+
+        @router.get("", response_model=ListThreadsResponse)
+        async def list_threads(
+            thread_type: Optional[str] = Query(None),
+            title_contains: Optional[str] = Query(None),
+            min_messages: Optional[int] = Query(None),
+            max_messages: Optional[int] = Query(None),
+            hours_ago: Optional[int] = Query(None),
+            user: BaseUser = Depends(get_current_user),
+        ):
+            """List threads with filtering"""
+            filter_builder = ThreadFilter.builder()
+
+            filter_builder.with_author_id(user.get_id())
+            if thread_type:
+                filter_builder.with_type(thread_type)
+            if title_contains:
+                filter_builder.with_title_containing(title_contains)
+            if min_messages:
+                filter_builder.with_min_messages(min_messages)
+            if max_messages:
+                filter_builder.with_max_messages(max_messages)
+            if hours_ago:
+                cutoff = int((time.time() - hours_ago * 3600) * 1000)
+                filter_builder.with_activity_after(cutoff)
+
+            filter = filter_builder.build()
+            threads = await self.service.list_threads(filter)
+
+            return ListThreadsResponse(threads=ThreadConverters.metadata_list_to_response(threads), total_count=len(threads))
+
+        @router.get("/{thread_id}/messages", response_model=List[MessageResponse])
+        async def get_thread_messages(thread_id: str, user: BaseUser = Depends(get_current_user)):
+            """Get all messages for a thread"""
+            thread = await self.service.get_thread(thread_id)
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+            if not await self.authorizer.can_read_thread(user, thread):
+                raise HTTPException(status_code=403, detail="Access denied")
+
+            messages = await self.service.get_thread_messages(thread_id)
+            return ThreadConverters.messages_model_to_response(messages)
+
+        @router.get("/{thread_id}/messages/{message_id}", response_model=MessageResponse)
+        async def get_message(thread_id: str, message_id: str, user: BaseUser = Depends(get_current_user)):
+            """Get specific message by ID"""
+            thread = await self.service.get_thread(thread_id)
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+            if not await self.authorizer.can_read_thread(user, thread):
+                raise HTTPException(status_code=403, detail="Access denied")
+
+            message = await self.service.get_message(thread_id, message_id)
+            if not message:
+                raise HTTPException(status_code=404, detail="Message not found")
+            return ThreadConverters.message_model_to_response(message)
+
+        @router.delete("/{thread_id}/messages/{message_id}")
+        async def delete_message(thread_id: str, message_id: str, user: BaseUser = Depends(get_current_user)):
+            """Delete message from thread"""
+            thread = await self.service.get_thread(thread_id)
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+            if not await self.authorizer.can_post_message(user, thread):
+                raise HTTPException(status_code=403, detail="Access denied")
+
+            success = await self.service.delete_message(thread_id, message_id)
+            if not success:
+                raise HTTPException(status_code=404, detail="Message not found")
+            return {"message": "Message deleted successfully"}
+
+        @router.get("/{thread_id}/negotiate-streaming", response_model=ThreadResponse)
+        async def negotiate_streaming(thread_id: str, user: BaseUser = Depends(get_current_user)):
+            """Negotiate streaming"""
+            if not self.streaming_negotiator:
+                raise HTTPException(status_code=501, detail="Streaming negotiation not supported")
+
+            thread = await self.service.get_thread(thread_id)
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+            if not await self.authorizer.can_read_thread(user, thread):
+                raise HTTPException(status_code=403, detail="Access denied")
+
+            return self.streaming_negotiator.negotiate_thread_streaming(thread_id, user)
+
+        async def _create_message(thread_id: str, request: CreateMessageRequest, user: BaseUser) -> ThreadMessage:
+            """Create a new message"""
+
+            thread = await self.service.get_thread(thread_id)
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+
+            if not await self.authorizer.can_post_message(user, thread):
+                raise HTTPException(status_code=403, detail="Access denied")
+
+            attachments = None
+            if request.attachments:
+                attachments = [ThreadConverters.attachment_request_to_model(att) for att in request.attachments]
+
+            message = ThreadMessage(
+                id=str(uuid.uuid4()),
+                author_id=user.get_id(),
+                author_name=user.get_name(),
+                timestamp=int(time.time() * 1000),
+                ai=False,
+                blocks=[MessageBlock(content=request.content, type=MessageBlockType.PLAIN, id=str(uuid.uuid4()), streaming=False)],
+                attachments=attachments,
+            )
+            thread.add_message(message)
+            await self.service.update_thread(thread)
+            return message
+
+        @router.post("/{thread_id}/messages/stream")
+        async def create_message_stream(thread_id: str, request: CreateMessageRequest, user: BaseUser = Depends(get_current_user)):
+            """Create a new message and stream the response immediately"""
+
+            if not self.thread_job_processor:
+                raise HTTPException(status_code=501, detail="Thread job processor not supported")
+            message = await _create_message(thread_id, request, user)
+
+            job = AgentJob(job_type=JobType.THREAD_MESSAGE, id=thread_id)
+            cancellation_subscriber = (
+                await self.cancellation_subscriber_provider(thread_id) if self.cancellation_subscriber_provider else None
+            )
+            cancellation_handle = cancellation_subscriber.get_cancellation_handle() if cancellation_subscriber else None
+
+            def on_complete():
+                if cancellation_subscriber:
+                    cancellation_subscriber.stop()
+
+            logger.debug(f"Starting processing for thread {thread_id}")
+
+            async def generate_stream():
+                try:
+                    logger.debug(f"Starting streaming stream for thread {thread_id}")
+                    yield MessageAddedEvent(message=message).dump_json(thread_id) + "\n\n"
+
+                    async for event_response in self.thread_job_processor.process_job(
+                        job=job, cancellation_handle=cancellation_handle, on_complete=on_complete
+                    ):
+                        logger.debug(f"Received event response: {event_response}")
+                        yield json.dumps(event_response) + "\n\n"
+
+                except Exception as e:
+                    logger.error(f"Error in SSE stream: {e}")
+                    yield f'data: {{"error": "{str(e)}"}}\n\n'
+
+            logger.info(f"StreamingResponse for job {thread_id}")
+            return StreamingResponse(
+                generate_stream(),
+                media_type="text/plain; charset=utf-8",  # devtools are not happy with the proper mime type
+                headers={
+                    "Cache-Control": "no-cache",
+                    # "Connection": "keep-alive",
+                    "Access-Control-Allow-Origin": "*",
+                    "Access-Control-Allow-Headers": "Cache-Control",
+                    "X-Accel-Buffering": "no",  # Disable nginx buffering
+                },
+            )
+
+        @router.post("/{thread_id}/messages", response_model=MessageResponse)
+        async def create_message(thread_id: str, request: CreateMessageRequest, user: BaseUser = Depends(get_current_user)):
+            """Create a new message"""
+            if not self.job_queue:
+                raise HTTPException(status_code=501, detail="Job queue not supported")
+
+            message = await _create_message(thread_id, request, user)
+
+            job = AgentJob(job_type=JobType.THREAD_MESSAGE, id=thread_id)
+            await self.job_queue.push(job)
+            return ThreadConverters.message_model_to_response(message)
+
+        @router.post("/{thread_id}/cancel")
+        async def cancel_generation(thread_id: str, user: BaseUser = Depends(get_current_user)):
+            """Cancel the current generation for a thread"""
+            thread = await self.service.get_thread(thread_id)
+            if not thread:
+                raise HTTPException(status_code=404, detail="Thread not found")
+
+            if not await self.authorizer.can_post_message(user, thread):
+                raise HTTPException(status_code=403, detail="Access denied")
+
+            if self.cancellation_publisher:
+                self.cancellation_publisher.publish_cancellation(thread_id)
+                logger.info(f"Cancellation published for thread {thread_id}")
+                return {"success": True, "message": "Cancellation signal sent"}
+            else:
+                raise HTTPException(status_code=501, detail="Cancellation not supported")
+
+        return router

spaik_sdk/server/api/streaming/format_sse_event.py

@@ -0,0 +1,41 @@
+import json
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel
+
+from spaik_sdk.utils.init_logger import init_logger
+
+logger = init_logger(__name__)
+
+
+class EventStreamResponse(BaseModel):
+    event: Optional[str] = None
+    payload: Union[str, dict[str, Any]]
+
+
+def format_sse_event(event_response: Dict[str, Any]) -> str:
+    """Format EventStreamResponse as SSE data"""
+
+    # Build SSE message
+    sse_lines: list[str] = []
+
+    # Add event type if present
+    if event_response.get("event_type"):
+        sse_lines.append(f"event: {event_response['event_type']}")
+
+    payload_obj = event_response.get("data")
+
+    # Serialize payload to JSON-safe string
+    try:
+        if isinstance(payload_obj, str):
+            data_content = payload_obj
+        else:
+            data_content = json.dumps(payload_obj)
+    except Exception as err:
+        logger.warning(f"Failed to JSON serialize payload ({err}), using repr")
+        data_content = repr(payload_obj)
+
+    sse_lines.append(f"data: {data_content}")
+
+    # SSE format requires double newline at end
+    return "\n".join(sse_lines) + "\n\n"

spaik_sdk/server/api/streaming/negotiate_streaming_response.py

@@ -0,0 +1,8 @@
+from typing import Any, Dict
+
+from pydantic import BaseModel
+
+
+class NegotiateStreamingResponse(BaseModel):
+    mode: str
+    config: Dict[str, Any]

spaik_sdk/server/api/streaming/streaming_negotiator.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+from spaik_sdk.server.api.streaming.negotiate_streaming_response import NegotiateStreamingResponse
+from spaik_sdk.server.authorization.base_user import BaseUser
+
+
+class StreamingNegotiator(ABC):
+    @abstractmethod
+    def negotiate_thread_streaming(self, thread_id: str, user: BaseUser) -> NegotiateStreamingResponse:
+        pass

spaik_sdk/server/authorization/base_authorizer.py

@@ -0,0 +1,64 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar
+
+from fastapi import Request
+
+from spaik_sdk.server.authorization.base_user import BaseUser
+from spaik_sdk.thread.models import ThreadMessage
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+if TYPE_CHECKING:
+    from spaik_sdk.attachments.models import FileMetadata
+
+TUser = TypeVar("TUser", bound=BaseUser)
+
+
+class BaseAuthorizer(ABC, Generic[TUser]):
+    """Abstract base for authorization"""
+
+    @abstractmethod
+    async def get_user(self, request: Request) -> Optional[TUser]:
+        """Get user from request"""
+        pass
+
+    async def can_create_thread(
+        self,
+        user: TUser,
+    ) -> bool:
+        """Check if user has permission for the thread"""
+        return True
+
+    async def can_read_thread(self, user: TUser, thread_container: ThreadContainer) -> bool:
+        """Check if user has permission to read the thread"""
+        return self.is_thread_owner(user, thread_container)
+
+    async def can_post_message(self, user: TUser, thread_container: ThreadContainer) -> bool:
+        """Check if user has permission to post a message to the thread"""
+        return self.is_thread_owner(user, thread_container)
+
+    async def can_edit_message(self, user: TUser, thread_container: ThreadContainer, message: ThreadMessage) -> bool:
+        """Check if user has permission to edit a message in the thread"""
+        return message.author_id == user.get_id()
+
+    async def can_delete_thread(self, user: TUser, thread_container: ThreadContainer) -> bool:
+        """Check if user has permission to delete the thread"""
+        return self.is_thread_owner(user, thread_container)
+
+    def is_thread_owner(self, user: TUser, thread_container: ThreadContainer) -> bool:
+        """Check if user is the owner of the thread"""
+        return thread_container.messages[0].author_id == user.get_id()
+
+    async def can_upload_file(self, user: TUser) -> bool:
+        """Check if user has permission to upload files"""
+        return True
+
+    async def can_read_file(self, user: TUser, file_metadata: "FileMetadata") -> bool:
+        """Check if user has permission to read a file.
+        
+        By default, users can read files they own, or files owned by 'system' (agent-generated).
+        """
+        return file_metadata.owner_id == user.get_id() or file_metadata.owner_id == "system"
+
+    async def can_delete_file(self, user: TUser, file_metadata: "FileMetadata") -> bool:
+        """Check if user has permission to delete a file"""
+        return file_metadata.owner_id == user.get_id()

spaik_sdk/server/authorization/base_user.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+
+class BaseUser:
+    def __init__(self, id: str, name: Optional[str] = None):
+        self.id = id
+        self.name = name
+
+    def get_id(self) -> str:
+        return self.id
+
+    def get_name(self) -> str:
+        return self.name or self.id

spaik_sdk/server/authorization/dummy_authorizer.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from fastapi import Request
+
+from spaik_sdk.server.authorization.base_authorizer import BaseAuthorizer
+from spaik_sdk.server.authorization.base_user import BaseUser
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class DummyAuthorizer(BaseAuthorizer[BaseUser]):
+    """Dummy authorizer that always returns True"""
+
+    async def get_user(self, request: Request) -> Optional[BaseUser]:
+        return BaseUser("user")
+
+    def is_thread_owner(self, user: BaseUser, thread_container: ThreadContainer) -> bool:
+        return True

spaik_sdk/server/job_processor/base_job_processor.py

@@ -0,0 +1,8 @@
+from abc import ABC
+
+
+class BaseJobProcessor(ABC):
+    """Interface for processing agent jobs"""
+
+    def __init__(self):
+        pass

spaik_sdk/server/job_processor/thread_job_processor.py

@@ -0,0 +1,32 @@
+from collections.abc import Callable
+from typing import Any, AsyncGenerator, Dict, Optional
+
+from fastapi import HTTPException
+
+from spaik_sdk.llm.cancellation_handle import CancellationHandle
+from spaik_sdk.server.job_processor.base_job_processor import BaseJobProcessor
+from spaik_sdk.server.queue.agent_job_queue import AgentJob
+from spaik_sdk.server.response.response_generator import ResponseGenerator
+from spaik_sdk.server.services.thread_service import ThreadService
+
+
+class ThreadJobProcessor(BaseJobProcessor):
+    def __init__(self, thread_service: ThreadService, response_generator: ResponseGenerator):
+        super().__init__()
+        self.thread_service = thread_service
+        self.response_generator = response_generator
+
+    async def process_job(
+        self,
+        job: AgentJob,
+        cancellation_handle: Optional[CancellationHandle],
+        on_complete: Callable[[], None] = lambda: None,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        thread_container = await self.thread_service.get_thread(job.id)
+        if thread_container is None:
+            raise HTTPException(status_code=404, detail="Thread not found")
+        # thread_event_publisher.bind_container(thread_container)
+        async for chunk in self.response_generator.stream_response(thread_container, cancellation_handle):
+            yield chunk
+        await self.thread_service.update_thread(thread_container)
+        on_complete()

spaik_sdk/server/pubsub/__init__.py

@@ -0,0 +1 @@
+

spaik_sdk/server/pubsub/cancellation_publisher.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class CancellationPublisher(ABC):
+    @abstractmethod
+    def publish_cancellation(self, id: str) -> None:
+        pass

spaik_sdk/server/pubsub/cancellation_subscriber.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+
+from spaik_sdk.llm.cancellation_handle import CancellationHandle
+
+
+class CancellationSubscriberHandler(CancellationHandle):
+    def __init__(self) -> None:
+        self.cancelled: bool = False
+
+    async def is_cancelled(self) -> bool:
+        return self.cancelled
+
+    def cancel(self) -> None:
+        self.cancelled = True
+
+
+class CancellationSubscriber(ABC):
+    def __init__(self, id: str):
+        self.id = id
+        self.cancellation_handle = CancellationSubscriberHandler()
+        self._subscribe_to_cancellation()
+
+    @abstractmethod
+    def _subscribe_to_cancellation(self) -> None:
+        pass
+
+    @abstractmethod
+    def _unsubscribe_from_cancellation(self) -> None:
+        pass
+
+    def get_cancellation_handle(self) -> CancellationHandle:
+        return self.cancellation_handle
+
+    def on_cancellation(self) -> None:
+        self.cancellation_handle.cancel()
+
+    def stop(self) -> None:
+        self._unsubscribe_from_cancellation()

spaik_sdk/server/pubsub/event_publisher.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+from spaik_sdk.utils.init_logger import init_logger
+
+logger = init_logger(__name__)
+
+
+class EventPublisher(ABC):
+    @abstractmethod
+    def publish_event(self, event: Dict[str, Any]) -> None:
+        """Publish event - implemented by subclasses"""
+        pass

spaik_sdk/server/pubsub/impl/__init__.py

@@ -0,0 +1 @@
+