spaik-sdk 0.6.2__py3-none-any.whl

spaik_sdk/server/pubsub/impl/local_cancellation_pubsub.py

@@ -0,0 +1,48 @@
+from spaik_sdk.server.pubsub.cancellation_publisher import CancellationPublisher
+from spaik_sdk.server.pubsub.cancellation_subscriber import CancellationSubscriber
+
+
+class LocalCancellationPubsub:
+    def __init__(self):
+        self.publisher = LocalCancellationPublisher()
+
+    def create_subscriber(self, id: str) -> CancellationSubscriber:
+        return LocalCancellationSubscriber(id, self.publisher)
+
+    def get_publisher(self) -> CancellationPublisher:
+        return self.publisher
+
+
+class LocalCancellationSubscriber(CancellationSubscriber):
+    def __init__(self, id: str, publisher: "LocalCancellationPublisher"):
+        self.publisher = publisher
+        super().__init__(id)
+
+    def _subscribe_to_cancellation(self) -> None:
+        self.publisher.subscribe(self)
+
+    def _unsubscribe_from_cancellation(self) -> None:
+        self.publisher.unsubscribe(self)
+
+
+class LocalCancellationPublisher(CancellationPublisher):
+    def __init__(self):
+        self.subscribers: list[CancellationSubscriber] = []
+
+    def subscribe(self, subscriber: CancellationSubscriber) -> None:
+        self.subscribers.append(subscriber)
+
+    def unsubscribe(self, subscriber: CancellationSubscriber) -> None:
+        self.subscribers.remove(subscriber)
+
+    def publish_cancellation(self, id: str) -> None:
+        for subscriber in self.subscribers:
+            if subscriber.id == id:
+                subscriber.on_cancellation()
+
+
+local_cancellation_pubsub = LocalCancellationPubsub()
+
+
+def get_local_cancellation_pubsub() -> LocalCancellationPubsub:
+    return local_cancellation_pubsub

spaik_sdk/server/pubsub/impl/signalr_publisher.py

@@ -0,0 +1,36 @@
+import json
+from typing import Any, Dict
+
+from spaik_sdk.utils.init_logger import init_logger
+
+logger = init_logger(__name__)
+
+
+# TODO turn into proper events, consider taking it to a different azure lib
+class SignalRPublisher:
+    """Azure SignalR publisher"""
+
+    def __init__(self, config, signalr_out):
+        """
+        Args:
+            signalr_out: Azure Functions SignalR output binding (func.Out[str])
+        """
+        # super().__init__(config)
+        self.signalr_out = signalr_out
+
+    def publish_event(self, event: Dict[str, Any], job_id: str) -> None:
+        """Publish event to Azure SignalR"""
+
+        # SignalR message format
+        signalr_message = {
+            "target": "agentEvent",  # Client-side method name
+            "arguments": [event],
+        }
+
+        # Send to SignalR
+        message_json = json.dumps(signalr_message)
+        self.signalr_out.set(message_json)
+
+        job_id = event.get("job_id", "unknown")
+        event_type = event.get("event_type", "unknown")
+        logger.debug(f"Published {event_type} to SignalR for job {job_id}")

spaik_sdk/server/queue/__init__.py

@@ -0,0 +1 @@
+

spaik_sdk/server/queue/agent_job_queue.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+
+from pydantic import BaseModel
+
+
+class JobType(Enum):
+    THREAD_MESSAGE = "thread_message"
+    ORCHESTRATION = "orchestration"
+
+
+class AgentJob(BaseModel):
+    id: str
+    job_type: JobType
+
+    def to_json(self) -> str:
+        """Convert AgentJob to JSON string"""
+        return self.model_dump_json()
+
+
+class AgentJobQueue(ABC):
+    """Minimal queue abstraction - just push jobs"""
+
+    @abstractmethod
+    async def push(self, job: AgentJob) -> None:
+        """Push job to queue"""
+        pass

spaik_sdk/server/queue/impl/__init__.py

@@ -0,0 +1 @@
+

spaik_sdk/server/queue/impl/azure_queue.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from spaik_sdk.server.queue.agent_job_queue import AgentJob
+from spaik_sdk.utils.init_logger import init_logger
+
+logger = init_logger(__name__)
+
+
+class AzureFunctionQueue:
+    """Azure Functions queue implementation"""
+
+    def __init__(self, func_out: Any):
+        """
+        Args:
+            func_out: Azure Functions queue output binding (func.Out[str])
+        """
+        self.func_out = func_out
+
+    async def push(self, job: AgentJob) -> None:
+        """Push job to Azure Functions queue"""
+        json_data = job.to_json()
+
+        # Set the message in the Azure Functions queue output
+        self.func_out.set(json_data)

spaik_sdk/server/response/agent_response_generator.py

@@ -0,0 +1,39 @@
+import time
+from collections.abc import Callable
+from typing import Any, AsyncGenerator, Dict, Optional, TypeVar
+
+from spaik_sdk.agent.base_agent import BaseAgent
+from spaik_sdk.llm.cancellation_handle import CancellationHandle
+from spaik_sdk.server.response.response_generator import ResponseGenerator
+from spaik_sdk.thread.models import ThreadEvent
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+TAgent = TypeVar("TAgent", bound=BaseAgent)
+
+
+class AgentResponseGenerator(ResponseGenerator):
+    def __init__(self, agent: TAgent, call_agent: Callable[[TAgent], AsyncGenerator[ThreadEvent, None]]):
+        self.agent = agent
+        self.call_agent = call_agent
+
+    async def stream_response(
+        self, thread: ThreadContainer, cancellation_handle: Optional[CancellationHandle] = None
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        self.agent.set_thread_container(thread)
+        self.agent.set_cancellation_handle(cancellation_handle)
+
+        # Stream from the agent execution
+        async for event in self.call_agent(self.agent):
+            if not event.is_publishable():
+                continue
+            yield self._convert_event(event, thread.thread_id)
+
+    def _convert_event(self, event: ThreadEvent, thread_id: str) -> Dict[str, Any]:
+        """Convert ThreadContainer event to publishable format"""
+
+        return {
+            "thread_id": thread_id,
+            "event_type": event.get_event_type(),
+            "timestamp": int(time.time() * 1000),
+            "data": event.get_event_data(),
+        }

spaik_sdk/server/response/response_generator.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+from typing import Any, AsyncGenerator, Dict, Optional
+
+from spaik_sdk.llm.cancellation_handle import CancellationHandle
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class ResponseGenerator(ABC):
+    @abstractmethod
+    def stream_response(
+        self, thread: ThreadContainer, cancellation_handle: Optional[CancellationHandle] = None
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        pass

spaik_sdk/server/response/simple_agent_response_generator.py

@@ -0,0 +1,14 @@
+from typing import AsyncGenerator
+
+from spaik_sdk.agent.base_agent import BaseAgent
+from spaik_sdk.server.response.agent_response_generator import AgentResponseGenerator
+from spaik_sdk.thread.models import ThreadEvent
+
+
+class SimpleAgentResponseGenerator(AgentResponseGenerator):
+    def __init__(self, agent: BaseAgent):
+        async def call_agent(agent: BaseAgent) -> AsyncGenerator[ThreadEvent, None]:
+            async for event in agent.get_event_stream():
+                yield event
+
+        super().__init__(agent, call_agent)

spaik_sdk/server/services/thread_converters.py

@@ -0,0 +1,113 @@
+import uuid
+from typing import List
+
+from spaik_sdk.attachments.models import Attachment
+from spaik_sdk.server.services.thread_models import (
+    AttachmentRequest,
+    AttachmentResponse,
+    MessageBlockRequest,
+    MessageBlockResponse,
+    MessageResponse,
+    ThreadMetadataResponse,
+    ThreadResponse,
+)
+from spaik_sdk.server.storage.thread_metadata import ThreadMetadata
+from spaik_sdk.thread.models import MessageBlock, ThreadMessage
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class ThreadConverters:
+    """Utility class for converting between internal and API models"""
+
+    @staticmethod
+    def block_request_to_model(request: MessageBlockRequest) -> MessageBlock:
+        """Convert MessageBlockRequest to MessageBlock"""
+        return MessageBlock(
+            id=str(uuid.uuid4()),
+            streaming=False,
+            type=request.type,
+            content=request.content,
+            tool_call_id=request.tool_call_id,
+            tool_call_args=request.tool_call_args,
+            tool_name=request.tool_name,
+        )
+
+    @staticmethod
+    def block_model_to_response(block: MessageBlock) -> MessageBlockResponse:
+        """Convert MessageBlock to MessageBlockResponse"""
+        return MessageBlockResponse(
+            id=block.id,
+            streaming=block.streaming,
+            type=block.type,
+            content=block.content,
+            tool_call_id=block.tool_call_id,
+            tool_call_args=block.tool_call_args,
+            tool_name=block.tool_name,
+            tool_call_response=block.tool_call_response,
+            tool_call_error=block.tool_call_error,
+        )
+
+    @staticmethod
+    def attachment_request_to_model(request: AttachmentRequest) -> Attachment:
+        """Convert AttachmentRequest to Attachment"""
+        return Attachment(
+            file_id=request.file_id,
+            mime_type=request.mime_type,
+            filename=request.filename,
+        )
+
+    @staticmethod
+    def attachment_model_to_response(attachment: Attachment) -> AttachmentResponse:
+        """Convert Attachment to AttachmentResponse"""
+        return AttachmentResponse(
+            file_id=attachment.file_id,
+            mime_type=attachment.mime_type,
+            filename=attachment.filename,
+        )
+
+    @staticmethod
+    def message_model_to_response(message: ThreadMessage) -> MessageResponse:
+        """Convert ThreadMessage to MessageResponse"""
+        attachments = None
+        if message.attachments:
+            attachments = [ThreadConverters.attachment_model_to_response(att) for att in message.attachments]
+        return MessageResponse(
+            id=message.id,
+            ai=message.ai,
+            author_id=message.author_id,
+            author_name=message.author_name,
+            timestamp=message.timestamp,
+            blocks=[ThreadConverters.block_model_to_response(block) for block in message.blocks],
+            attachments=attachments,
+        )
+
+    @staticmethod
+    def messages_model_to_response(messages: List[ThreadMessage]) -> List[MessageResponse]:
+        """Convert list of ThreadMessage to list of MessageResponse"""
+        return [ThreadConverters.message_model_to_response(msg) for msg in messages]
+
+    @staticmethod
+    def thread_model_to_response(thread: ThreadContainer) -> ThreadResponse:
+        """Convert ThreadContainer to ThreadResponse"""
+        return ThreadResponse(
+            id=thread.thread_id,
+            messages=[ThreadConverters.message_model_to_response(msg) for msg in thread.messages],
+        )
+
+    @staticmethod
+    def metadata_model_to_response(metadata: ThreadMetadata) -> ThreadMetadataResponse:
+        """Convert ThreadMetadata to ThreadMetadataResponse"""
+        return ThreadMetadataResponse(
+            thread_id=metadata.thread_id,
+            title=metadata.title,
+            message_count=metadata.message_count,
+            last_activity_time=metadata.last_activity_time,
+            created_at=metadata.created_at,
+            author_id=metadata.author_id,
+            type=metadata.type,
+        )
+
+    @staticmethod
+    def metadata_list_to_response(metadata_list: List[ThreadMetadata]) -> List[ThreadMetadataResponse]:
+        """Convert list of ThreadMetadata to list of ThreadMetadataResponse"""
+        return [ThreadConverters.metadata_model_to_response(metadata) for metadata in metadata_list]

spaik_sdk/server/services/thread_models.py

@@ -0,0 +1,90 @@
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel
+
+from spaik_sdk.thread.models import MessageBlockType
+
+
+class MessageBlockRequest(BaseModel):
+    type: MessageBlockType
+    content: Optional[str] = None
+    tool_call_id: Optional[str] = None
+    tool_call_args: Optional[Dict[str, Any]] = None
+    tool_name: Optional[str] = None
+
+
+class MessageBlockResponse(BaseModel):
+    id: str
+    streaming: bool
+    type: MessageBlockType
+    content: Optional[str] = None
+    tool_call_id: Optional[str] = None
+    tool_call_args: Optional[Dict[str, Any]] = None
+    tool_name: Optional[str] = None
+    tool_call_response: Optional[str] = None
+    tool_call_error: Optional[str] = None
+
+
+class UpdateMessageRequest(BaseModel):
+    blocks: Optional[List[MessageBlockRequest]] = None
+
+
+class AttachmentRequest(BaseModel):
+    file_id: str
+    mime_type: str
+    filename: Optional[str] = None
+
+
+class AttachmentResponse(BaseModel):
+    file_id: str
+    mime_type: str
+    filename: Optional[str] = None
+
+
+class MessageResponse(BaseModel):
+    id: str
+    ai: bool
+    author_id: str
+    author_name: str
+    timestamp: int
+    blocks: List[MessageBlockResponse]
+    attachments: Optional[List[AttachmentResponse]] = None
+
+
+class CreateMessageRequest(BaseModel):
+    content: str
+    attachments: Optional[List[AttachmentRequest]] = None
+
+
+class CreateThreadRequest(BaseModel):
+    job_id: Optional[str] = "unknown"
+    # TODO add metadata, remove job_id
+
+
+class ThreadResponse(BaseModel):
+    id: str
+    messages: List[MessageResponse]
+
+
+class ThreadMetadataResponse(BaseModel):
+    thread_id: str
+    title: str
+    message_count: int
+    last_activity_time: int
+    created_at: int
+    author_id: str
+    type: str
+
+
+class ListThreadsRequest(BaseModel):
+    author_id: Optional[str] = None
+    thread_type: Optional[str] = None
+    title_contains: Optional[str] = None
+    min_messages: Optional[int] = None
+    max_messages: Optional[int] = None
+    hours_ago: Optional[int] = None
+
+
+class ListThreadsResponse(BaseModel):
+    threads: List[ThreadMetadataResponse]
+    total_count: int

spaik_sdk/server/services/thread_service.py

@@ -0,0 +1,91 @@
+from typing import List, Optional
+
+from spaik_sdk.server.storage.base_thread_repository import BaseThreadRepository
+from spaik_sdk.server.storage.thread_filter import ThreadFilter
+from spaik_sdk.server.storage.thread_metadata import ThreadMetadata
+from spaik_sdk.thread.models import ThreadMessage
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class ThreadService:
+    """High-level service for thread and message operations"""
+
+    def __init__(self, repository: BaseThreadRepository):
+        self.repository = repository
+
+    # Thread operations
+    async def create_thread(self, thread_container: ThreadContainer) -> ThreadContainer:
+        """Create a new thread"""
+        await self.repository.save_thread(thread_container)
+        return thread_container
+
+    async def get_thread(self, thread_id: str) -> Optional[ThreadContainer]:
+        """Get thread by ID"""
+        return await self.repository.load_thread(thread_id)
+
+    async def update_thread(self, thread_container: ThreadContainer) -> Optional[ThreadContainer]:
+        """Update an existing thread"""
+        if not await self.repository.thread_exists(thread_container.thread_id):
+            return None
+
+        await self.repository.save_thread(thread_container)
+        return thread_container
+
+    async def delete_thread(self, thread_id: str) -> bool:
+        """Delete thread and all its messages"""
+        return await self.repository.delete_thread(thread_id)
+
+    async def thread_exists(self, thread_id: str) -> bool:
+        """Check if thread exists"""
+        return await self.repository.thread_exists(thread_id)
+
+    async def list_threads(self, filter: ThreadFilter) -> List[ThreadMetadata]:
+        """List threads matching filter"""
+        return await self.repository.list_threads(filter)
+
+    # Message operations
+    async def get_message(self, thread_id: str, message_id: str) -> Optional[ThreadMessage]:
+        """Get message by thread ID and message ID"""
+        return await self.repository.get_message(thread_id, message_id)
+
+    async def add_message(self, thread_id: str, message: ThreadMessage) -> Optional[ThreadMessage]:
+        """Add message to thread"""
+        if not await self.repository.thread_exists(thread_id):
+            return None
+
+        await self.repository.upsert_message(thread_id, message)
+        return message
+
+    async def update_message(self, thread_id: str, message: ThreadMessage) -> Optional[ThreadMessage]:
+        """Update existing message in thread"""
+        if not await self.repository.thread_exists(thread_id):
+            return None
+
+        # Check if message exists
+        existing_message = await self.repository.get_message(thread_id, message.id)
+        if not existing_message:
+            return None
+
+        await self.repository.upsert_message(thread_id, message)
+        return message
+
+    async def delete_message(self, thread_id: str, message_id: str) -> bool:
+        """Delete message from thread"""
+        if not await self.repository.thread_exists(thread_id):
+            return False
+
+        # Check if message exists
+        existing_message = await self.repository.get_message(thread_id, message_id)
+        if not existing_message:
+            return False
+
+        await self.repository.delete_message(thread_id, message_id)
+        return True
+
+    async def get_thread_messages(self, thread_id: str) -> List[ThreadMessage]:
+        """Get all messages for a thread"""
+        thread = await self.repository.load_thread(thread_id)
+        if not thread:
+            return []
+
+        return thread.messages

spaik_sdk/server/storage/__init__.py

@@ -0,0 +1 @@
+

spaik_sdk/server/storage/base_thread_repository.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+from spaik_sdk.server.storage.thread_filter import ThreadFilter
+from spaik_sdk.server.storage.thread_metadata import ThreadMetadata
+from spaik_sdk.thread.models import ThreadMessage
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class BaseThreadRepository(ABC):
+    """Abstract base class for thread persistence"""
+
+    @abstractmethod
+    async def save_thread(self, thread_container: ThreadContainer) -> None:
+        """Save complete thread container to storage"""
+        pass
+
+    @abstractmethod
+    async def load_thread(self, thread_id: str) -> Optional[ThreadContainer]:
+        """Load thread container from storage"""
+        pass
+
+    @abstractmethod
+    async def get_message(self, thread_id: str, message_id: str) -> Optional[ThreadMessage]:
+        """Get message from storage"""
+        pass
+
+    @abstractmethod
+    async def upsert_message(self, thread_id: str, message: ThreadMessage) -> None:
+        """Upsert message to storage"""
+        pass
+
+    @abstractmethod
+    async def delete_message(self, thread_id: str, message_id: str) -> None:
+        """Delete message from storage"""
+        pass
+
+    @abstractmethod
+    async def thread_exists(self, thread_id: str) -> bool:
+        """Check if thread exists"""
+        pass
+
+    @abstractmethod
+    async def delete_thread(self, thread_id: str) -> bool:
+        """Delete thread and all its messages"""
+        pass
+
+    @abstractmethod
+    async def list_threads(self, filter: ThreadFilter) -> List[ThreadMetadata]:
+        """List threads for a given filter"""
+        pass

spaik_sdk/server/storage/impl/in_memory_thread_repository.py

@@ -0,0 +1,100 @@
+from typing import Dict, List, Optional
+
+from spaik_sdk.server.storage.base_thread_repository import BaseThreadRepository
+from spaik_sdk.server.storage.thread_filter import ThreadFilter
+from spaik_sdk.server.storage.thread_metadata import ThreadMetadata
+from spaik_sdk.thread.models import ThreadMessage
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class InMemoryThreadRepository(BaseThreadRepository):
+    """In-memory implementation of thread repository for testing/development"""
+
+    def __init__(self):
+        self._threads: Dict[str, ThreadContainer] = {}
+        self._metadata: Dict[str, ThreadMetadata] = {}
+
+    async def save_thread(self, thread_container: ThreadContainer) -> None:
+        """Save complete thread container to memory"""
+        self._threads[thread_container.thread_id] = thread_container
+        # Update metadata
+        metadata = ThreadMetadata.from_thread_container(thread_container)
+        self._metadata[thread_container.thread_id] = metadata
+
+    async def load_thread(self, thread_id: str) -> Optional[ThreadContainer]:
+        """Load thread container from memory"""
+        return self._threads.get(thread_id)
+
+    async def get_message(self, thread_id: str, message_id: str) -> Optional[ThreadMessage]:
+        """Get message from memory"""
+        thread = self._threads.get(thread_id)
+        if not thread:
+            return None
+
+        for message in thread.messages:
+            if message.id == message_id:
+                return message
+        return None
+
+    async def upsert_message(self, thread_id: str, message: ThreadMessage) -> None:
+        """Upsert message to memory"""
+        thread = self._threads.get(thread_id)
+        if not thread:
+            return
+
+        # Find existing message and replace, or add new one
+        for i, existing_msg in enumerate(thread.messages):
+            if existing_msg.id == message.id:
+                thread.messages[i] = message
+                break
+        else:
+            thread.messages.append(message)
+
+        # Update metadata
+        metadata = ThreadMetadata.from_thread_container(thread)
+        self._metadata[thread_id] = metadata
+
+    async def delete_message(self, thread_id: str, message_id: str) -> None:
+        """Delete message from memory"""
+        thread = self._threads.get(thread_id)
+        if not thread:
+            return
+
+        thread.messages = [msg for msg in thread.messages if msg.id != message_id]
+
+        # Update metadata
+        metadata = ThreadMetadata.from_thread_container(thread)
+        self._metadata[thread_id] = metadata
+
+    async def thread_exists(self, thread_id: str) -> bool:
+        """Check if thread exists in memory"""
+        return thread_id in self._threads
+
+    async def delete_thread(self, thread_id: str) -> bool:
+        """Delete thread and all its messages from memory"""
+        if thread_id in self._threads:
+            del self._threads[thread_id]
+            if thread_id in self._metadata:
+                del self._metadata[thread_id]
+            return True
+        return False
+
+    async def list_threads(self, filter: ThreadFilter) -> List[ThreadMetadata]:
+        """List threads matching the filter from memory"""
+        result = []
+        for metadata in self._metadata.values():
+            if filter.matches(metadata):
+                result.append(metadata)
+
+        # Sort by last activity time (most recent first)
+        result.sort(key=lambda x: x.last_activity_time, reverse=True)
+        return result
+
+    def clear_all(self) -> None:
+        """Clear all data (useful for testing)"""
+        self._threads.clear()
+        self._metadata.clear()
+
+    def get_thread_count(self) -> int:
+        """Get total number of threads stored"""
+        return len(self._threads)