spaik-sdk 0.6.2__py3-none-any.whl

spaik_sdk/thread/adapters/cli/live_cli.py

@@ -0,0 +1,235 @@
+import asyncio
+import sys
+from typing import List
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+from spaik_sdk.thread.adapters.cli.block_display import BlockDisplayType
+from spaik_sdk.thread.adapters.cli.display_manager import DisplayManager
+from spaik_sdk.thread.models import (
+    BlockAddedEvent,
+    MessageBlockType,
+    StreamingEndedEvent,
+    StreamingUpdatedEvent,
+    ThreadEvent,
+    ToolResponseReceivedEvent,
+)
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+SHOULD_INITIALIZE_DISPLAY = False
+
+
+class LiveCLI:
+    """Simple event-driven CLI that listens to ThreadContainer events"""
+
+    def __init__(self, container: ThreadContainer):
+        self.container = container
+        self.display_manager = DisplayManager()
+        self._running = False
+        self.console = Console()
+        self.events: List[ThreadEvent] = []
+
+    async def run(self, response_stream) -> "LiveCLI":
+        """Run the CLI with an async generator stream - handles everything internally"""
+        self.start()
+
+        try:
+            # Consume the response stream
+            async for token_data in response_stream:
+                # Stream processing happens automatically via events
+                pass
+
+            # Wait for streaming to complete
+            await self._wait_for_completion()
+
+        finally:
+            self.stop()
+
+        return self
+
+    async def run_interactive(self, agent) -> "LiveCLI":
+        """Run the CLI in interactive mode with a BaseAgent"""
+        from spaik_sdk.agent.base_agent import BaseAgent
+
+        if not isinstance(agent, BaseAgent):
+            raise ValueError("Agent must be an instance of BaseAgent")
+
+        # Use simple print statements for cleaner display
+        print("\n🤖 Interactive Agent Mode")
+        print("Type 'quit', 'exit', or 'q' to stop")
+        print("-" * 40)
+
+        while True:
+            try:
+                # Ensure clean state before input
+                sys.stdout.flush()
+                sys.stderr.flush()
+
+                # Get user input using Rich's prompt (blocking but clean)
+                user_input = await self._get_input_safe()
+
+                # Check for exit commands
+                if user_input.lower().strip() in ["quit", "exit", "q"]:
+                    print("\n👋 Goodbye!")
+                    break
+
+                if not user_input.strip():
+                    continue
+
+                # Start live display for response processing
+                if self._running:
+                    self.stop()
+                self.start()
+
+                try:
+                    # Get response stream from agent
+                    response_stream = agent.get_response_stream(user_input)
+
+                    # Consume the response stream
+                    async for token_data in response_stream:
+                        # Stream processing happens automatically via events
+                        pass
+
+                    # Wait for streaming to complete
+                    await self._wait_for_completion()
+
+                finally:
+                    # Always stop live display after response with proper cleanup
+                    await self._safe_stop()
+
+            except KeyboardInterrupt:
+                print("\n\n👋 Goodbye!")
+                break
+            except Exception as e:
+                print(f"\n❌ Error: {e}")
+                print("Try again...")
+
+        return self
+
+    async def _get_input_safe(self) -> str:
+        """Get user input safely without blocking issues"""
+        loop = asyncio.get_event_loop()
+        try:
+            # Use Rich's prompt in executor to avoid blocking
+            return await loop.run_in_executor(None, Prompt.ask, "\n💬 You")
+        except (EOFError, KeyboardInterrupt):
+            return "quit"
+
+    async def _safe_stop(self):
+        """Safely stop the display with proper error handling"""
+        try:
+            # Small delay to let display finish
+            await asyncio.sleep(0.2)
+            # Flush before stopping
+            sys.stdout.flush()
+            sys.stderr.flush()
+            self.stop()
+        except (BlockingIOError, OSError, Exception):
+            # If stopping fails, force reset the display state
+            self._running = False
+            if hasattr(self.display_manager, "live") and self.display_manager.live:
+                try:
+                    self.display_manager.live = None
+                except Exception:
+                    pass
+
+    async def _wait_for_completion(self):
+        """Wait for streaming to complete"""
+        # Wait for streaming to actually start
+        await asyncio.sleep(1.0)
+
+        # Wait for completion
+        while self.container.is_streaming_active():
+            await asyncio.sleep(0.1)
+
+        # Give it a moment to finalize
+        await asyncio.sleep(1.0)
+
+    def start(self):
+        """Start live display"""
+        if self._running:
+            return
+
+        self._running = True
+
+        self.display_manager.start()
+
+        # Subscribe to events BEFORE display manager is ready
+        self.container.subscribe(self._handle_event)
+        # Initialize display with existing blocks
+        if SHOULD_INITIALIZE_DISPLAY:
+            self._initialize_display()
+
+    def stop(self):
+        """Stop live display"""
+        if not self._running:
+            return
+
+        # Unsubscribe from events FIRST
+        self.container.unsubscribe(self._handle_event)
+
+        self._running = False
+        self.display_manager.stop()
+
+    def _initialize_display(self):
+        """Initialize display with existing blocks from ThreadContainer state"""
+        for message in self.container.messages:
+            for block in message.blocks:
+                display_type = self._get_display_type(block)
+                content = self.container.get_block_content(block)
+                self.display_manager.add_block(
+                    block.id, display_type, content=content, streaming=block.streaming, tool_name=block.tool_name
+                )
+
+    def _handle_event(self, event: ThreadEvent):
+        """Handle all ThreadContainer events with targeted updates"""
+        self.events.append(event)
+
+        if isinstance(event, StreamingUpdatedEvent):
+            self.display_manager.update_block_content(event.block_id, event.total_content, streaming=True)
+
+        elif isinstance(event, ToolResponseReceivedEvent):
+            if event.block_id:
+                self.display_manager.update_tool_result(event.block_id, event.response if not event.error else "", error=event.error)
+
+        elif isinstance(event, BlockAddedEvent):
+            # Add the new block to display
+            display_type = self._get_display_type(event.block)
+            content = self.container.get_block_content(event.block)
+            self.display_manager.add_block(
+                event.block_id, display_type, content=content, streaming=event.block.streaming, tool_name=event.block.tool_name
+            )
+
+        elif isinstance(event, StreamingEndedEvent):
+            for block_id in event.completed_blocks:
+                self.display_manager.update_block_content(block_id, streaming=False)
+
+    def _find_block_by_id(self, block_id: str):
+        """Find a block by its ID"""
+        for message in self.container.messages:
+            for block in message.blocks:
+                if block.id == block_id:
+                    return block
+        return None
+
+    def _find_tool_block_by_call_id(self, tool_call_id: str):
+        """Find a tool block by its call ID"""
+        for message in self.container.messages:
+            for block in message.blocks:
+                if block.type == MessageBlockType.TOOL_USE and block.tool_call_id == tool_call_id:
+                    return block
+        return None
+
+    def _get_display_type(self, block) -> BlockDisplayType:
+        """Convert MessageBlockType to BlockDisplayType"""
+        if block.type == MessageBlockType.REASONING:
+            return BlockDisplayType.REASONING
+        elif block.type == MessageBlockType.PLAIN:
+            return BlockDisplayType.RESPONSE
+        elif block.type == MessageBlockType.TOOL_USE:
+            return BlockDisplayType.TOOL_CALL
+        elif block.type == MessageBlockType.ERROR:
+            return BlockDisplayType.ERROR
+        else:
+            return BlockDisplayType.RESPONSE  # fallback

spaik_sdk/thread/adapters/event_adapter.py

@@ -0,0 +1,28 @@
+"""
+Simple synchronous adapter for ThreadContainer
+"""
+
+from typing import List
+
+from spaik_sdk.thread.models import ThreadEvent
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class EventAdapter:
+    def __init__(self, container: ThreadContainer):
+        self.events: List[ThreadEvent] = []
+        self.container = container
+
+        self.container.subscribe(self._handle_event)
+
+    def _handle_event(self, event: ThreadEvent):
+        self.events.append(event)
+
+    def flush(self) -> List[ThreadEvent]:
+        ret = self.events
+        self.events = []
+        return ret
+
+    def cleanup(self):
+        """Unsubscribe from events"""
+        self.container.unsubscribe(self._handle_event)

spaik_sdk/thread/adapters/streaming_block_adapter.py

@@ -0,0 +1,57 @@
+"""
+Streaming block adapter that yields blocks as they appear
+"""
+
+import asyncio
+from typing import AsyncGenerator
+
+from spaik_sdk.thread.models import BlockAddedEvent, MessageBlock, ThreadEvent
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class StreamingBlockAdapter:
+    """Adapter that streams blocks as they are created until streaming ends"""
+
+    def __init__(self, container: ThreadContainer):
+        self.container = container
+        self._block_queue: asyncio.Queue[MessageBlock] = asyncio.Queue()
+        self._streaming_ended = False
+
+        # Subscribe to events
+        self.container.subscribe(self._handle_event)
+
+    def _handle_event(self, event: ThreadEvent):
+        """Handle ThreadContainer events"""
+        if isinstance(event, BlockAddedEvent):
+            # Queue the new block
+            asyncio.create_task(self._queue_block(event.block))
+
+    async def _queue_block(self, block: MessageBlock):
+        """Add block to queue"""
+        await self._block_queue.put(block)
+
+    async def stream_blocks(self) -> AsyncGenerator[MessageBlock, None]:
+        """
+        Async generator that yields blocks as they are created.
+        Ends when streaming is no longer active.
+        """
+        try:
+            while True:
+                # Check if streaming is still active
+                if not self.container.is_streaming_active() and self._block_queue.empty():
+                    break
+
+                try:
+                    # Wait for next block with timeout to check streaming status periodically
+                    block = await asyncio.wait_for(self._block_queue.get(), timeout=0.1)
+                    yield block
+                except asyncio.TimeoutError:
+                    # Continue loop to check streaming status
+                    continue
+
+        finally:
+            self.cleanup()
+
+    def cleanup(self):
+        """Unsubscribe from events"""
+        self.container.unsubscribe(self._handle_event)

spaik_sdk/thread/adapters/sync_adapter.py

@@ -0,0 +1,76 @@
+"""
+Simple synchronous adapter for ThreadContainer
+"""
+
+import asyncio
+import time
+from typing import Optional
+
+from spaik_sdk.llm.cancellation_handle import CancellationHandle
+from spaik_sdk.thread.models import StreamingEndedEvent, ThreadEvent, ThreadMessage
+from spaik_sdk.thread.thread_container import ThreadContainer
+
+
+class SyncAdapter:
+    """Simple adapter that synchronously waits for streaming to end and returns final message"""
+
+    def __init__(self, container: ThreadContainer, cancellation_handle: Optional[CancellationHandle] = None):
+        self.container = container
+        self._streaming_ended = False
+        self.cancellation_handle = cancellation_handle
+
+        # Subscribe to events
+        self.container.subscribe(self._handle_event)
+
+    def run(self, response_stream, timeout: float = 30.0) -> "SyncAdapter":
+        """Run the adapter with an async generator stream - handles everything internally"""
+        asyncio.run(self.run_async(response_stream, timeout))
+        return self
+
+    async def run_async(self, response_stream, timeout: float = 30.0) -> Optional[ThreadMessage]:
+        """Async version of run that consumes the stream and waits for completion"""
+        try:
+            # Consume the response stream
+            async for token_data in response_stream:
+                # Stream processing happens automatically via events
+                pass
+
+            # Wait for streaming to complete
+            return await self.wait_for_completion_async(timeout)
+
+        finally:
+            pass  # Could add cleanup here if needed
+
+    def _handle_event(self, event: ThreadEvent):
+        """Handle ThreadContainer events"""
+        if isinstance(event, StreamingEndedEvent):
+            self._streaming_ended = True
+
+    def wait_for_completion(self, timeout: float = 30.0) -> Optional[ThreadMessage]:
+        """Wait for streaming to complete and return the latest AI message"""
+        return asyncio.run(self.wait_for_completion_async(timeout))
+
+    async def wait_for_completion_async(self, timeout: float = 30.0) -> Optional[ThreadMessage]:
+        """Async version of wait_for_completion"""
+        start_time = time.time()
+
+        # Wait for streaming to end
+        while time.time() - start_time < timeout:
+            if self._streaming_ended or not self.container.is_streaming_active():
+                # Give it a moment to finalize
+                await asyncio.sleep(0.1)
+                return self.container.get_latest_ai_message()
+
+        # Timeout - return what we have
+        return self.container.get_latest_ai_message()
+
+    def get_final_response(self) -> str:
+        """Get the final text response"""
+        message = self.wait_for_completion()
+        if message:
+            return self.container.get_final_text_content()
+        return ""
+
+    def cleanup(self):
+        """Unsubscribe from events"""
+        self.container.unsubscribe(self._handle_event)

spaik_sdk/thread/models.py

@@ -0,0 +1,224 @@
+import json
+import time
+from abc import ABC
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from spaik_sdk.attachments.models import Attachment
+    from spaik_sdk.llm.consumption.token_usage import TokenUsage
+
+
+class MessageBlockType(Enum):
+    PLAIN = "plain"
+    REASONING = "reasoning"
+    TOOL_USE = "tool_use"
+    ERROR = "error"
+
+
+@dataclass
+class MessageBlock:
+    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
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "streaming": self.streaming,
+            "content": self.content,
+            "tool_call_id": self.tool_call_id,
+            "tool_call_args": self.tool_call_args,
+            "tool_name": self.tool_name,
+            "type": self.type.value,
+        }
+
+
+@dataclass
+class ThreadMessage:
+    id: str
+    ai: bool
+    author_id: str
+    author_name: str
+    timestamp: int  # UTC millis
+    blocks: List[MessageBlock]
+    consumption_metadata: Optional["TokenUsage"] = None
+    attachments: Optional[List["Attachment"]] = None
+
+    def get_text_content(self) -> str:
+        return "\n".join([(block.content or "") for block in self.blocks if block.type == MessageBlockType.PLAIN])
+
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "id": self.id,
+            "ai": self.ai,
+            "author_id": self.author_id,
+            "author_name": self.author_name,
+            "timestamp": self.timestamp,
+            "blocks": [block.to_dict() for block in self.blocks],
+        }
+        if self.consumption_metadata:
+            result["consumption_metadata"] = self.consumption_metadata
+        if self.attachments:
+            result["attachments"] = [att.to_dict() for att in self.attachments]
+        return result
+
+    def __repr__(self) -> str:
+        """Return a detailed string representation for debugging."""
+        blocks_info = []
+        for block in self.blocks:
+            block_repr = f"{block.type.value} ({block.id}, {block.streaming}):"
+            if block.content:
+                content_preview = block.content[:50] + "..." if len(block.content) > 50 else block.content
+                block_repr += f":{content_preview}"
+            if block.tool_name:
+                block_repr += f"[{block.tool_name}]"
+            blocks_info.append(block_repr)
+
+        return (
+            f"ThreadMessage(id='{self.id}', ai={self.ai}, "
+            f"author='{self.author_name}', timestamp={self.timestamp}, "
+            f"blocks=[{', '.join(blocks_info)}])"
+        )
+
+
+@dataclass
+class ToolCallResponse:
+    id: str
+    response: str
+    error: Optional[str] = None
+
+
+# Event system
+@dataclass
+class ThreadEvent(ABC):
+    """Abstract base class for all thread events"""
+
+    def get_event_type(self) -> str:
+        """Return the event type identifier"""
+        return fix_event_type(self.__class__.__name__)
+
+    def get_event_data(self) -> Optional[Dict[str, Any]]:
+        """Return the event data."""
+        return None
+
+    def is_publishable(self) -> bool:
+        """Return True if the event is publishable."""
+        return False
+
+    def dump_json(self, thread_id: str) -> str:
+        return json.dumps(
+            {
+                "thread_id": thread_id,
+                "event_type": self.get_event_type(),
+                "timestamp": int(time.time() * 1000),
+                "data": self.get_event_data(),
+            }
+        )
+
+
+@dataclass
+class PublishableEvent(ThreadEvent):
+    """Abstract base class for all publishable events"""
+
+    def get_event_data(self) -> Optional[Dict[str, Any]]:
+        """Return the event data."""
+        return self.__dict__
+
+    def is_publishable(self) -> bool:
+        """Return True if the event is publishable."""
+        return True
+
+
+@dataclass
+class InternalEvent(ThreadEvent):
+    """Abstract base class for all publishable events"""
+
+    def get_event_data(self) -> Optional[Dict[str, Any]]:
+        return None
+
+    def is_publishable(self) -> bool:
+        return False
+
+
+def fix_event_type(event_type: str) -> str:
+    """Fix the event type to be a valid event type"""
+    return event_type.replace("Event", "")
+
+
+@dataclass
+class StreamingUpdatedEvent(PublishableEvent):
+    block_id: str
+    content: str
+    total_content: str
+
+    def get_event_data(self) -> Optional[Dict[str, Any]]:
+        return {
+            "block_id": self.block_id,
+            "content": self.content,
+        }
+
+
+@dataclass
+class BlockAddedEvent(PublishableEvent):
+    message_id: str
+    block_id: str
+    block: MessageBlock
+
+    def get_event_data(self) -> Optional[Dict[str, Any]]:
+        return {"message_id": self.message_id, "block": self.block.to_dict()}
+
+
+@dataclass
+class ToolCallStartedEvent(InternalEvent):
+    tool_call_id: str
+    tool_name: str
+    message_id: str
+    block_id: str
+
+
+@dataclass
+class ToolResponseReceivedEvent(PublishableEvent):
+    tool_call_id: str
+    response: str
+    error: Optional[str] = None
+    block_id: Optional[str] = None
+
+
+@dataclass
+class StreamingEndedEvent(InternalEvent):
+    message_id: str
+    completed_blocks: List[str]
+
+
+@dataclass
+class MessageAddedEvent(PublishableEvent):
+    message: ThreadMessage
+
+    def get_event_data(self) -> Optional[Dict[str, Any]]:
+        return self.message.to_dict()
+
+
+@dataclass
+class MessageFullyAddedEvent(PublishableEvent):
+    message: ThreadMessage
+
+    def get_event_data(self) -> Optional[Dict[str, Any]]:
+        return {"message_id": self.message.id}
+
+
+@dataclass
+class BlockFullyAddedEvent(PublishableEvent):
+    block_id: str
+    message_id: str
+    block: MessageBlock
+
+    def get_event_data(self) -> Optional[Dict[str, Any]]:
+        return {"message_id": self.message_id, "block_id": self.block_id}