slide-space-monkey 0.1.1__py3-none-any.whl

slide_space_monkey-0.1.1.dist-info/METADATA

@@ -0,0 +1,418 @@
+Metadata-Version: 2.4
+Name: slide-space-monkey
+Version: 0.1.1
+Summary: A simple, powerful way to deploy Tyler AI agents as Slack bots
+Project-URL: Homepage, https://github.com/adamwdraper/slide
+Project-URL: Repository, https://github.com/adamwdraper/slide
+Project-URL: Bug Tracker, https://github.com/adamwdraper/slide/issues
+Author: adamwdraper
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.104.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.32.0
+Requires-Dist: slack-bolt>=1.18.0
+Requires-Dist: slide-narrator>=0.2.0
+Requires-Dist: slide-tyler>=1.1.0
+Requires-Dist: uvicorn[standard]>=0.24.0
+Requires-Dist: weave>=0.51.0
+Provides-Extra: dev
+Requires-Dist: coverage>=7.6.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.25.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Space Monkey - Tyler Slack Bot
+
+A simple, powerful way to deploy Tyler AI agents as Slack bots with just a few lines of code.
+
+## Overview
+
+Space Monkey provides a clean, class-based API for creating and deploying Tyler agents as Slack bots. It handles all the complexity of Slack integration, message routing, thread management, and storage while exposing a simple interface for agent configuration.
+
+## Features
+
+- **Simple API**: Just import `SlackApp`, `Agent`, and stores from one package
+- **Intelligent Message Routing**: Automatically classifies messages and routes appropriately
+- **Thread Management**: Persistent conversation threads with configurable storage backends
+- **File Handling**: Built-in support for file attachments and processing
+- **Health Monitoring**: Optional health check endpoints for production deployments
+- **Weave Integration**: Built-in tracing and monitoring support
+
+## Quick Start
+
+### 1. Install the Package
+
+```bash
+pip install slide-space-monkey
+```
+
+### 2. Set Up Environment Variables
+
+Create a `.env` file:
+
+```bash
+# Required: Slack Configuration
+SLACK_BOT_TOKEN=xoxb-your-bot-token
+SLACK_APP_TOKEN=xapp-your-app-token
+
+# Optional: Weave Monitoring
+WANDB_API_KEY=your-wandb-key
+WANDB_PROJECT=your-project-name
+
+# Optional: Health Check
+HEALTH_CHECK_URL=http://healthcheck:8000/ping-receiver
+
+# Optional: Database (defaults to in-memory)
+NARRATOR_DB_TYPE=postgresql
+NARRATOR_DB_USER=tyler
+NARRATOR_DB_PASSWORD=password
+NARRATOR_DB_HOST=localhost
+NARRATOR_DB_PORT=5432
+NARRATOR_DB_NAME=tyler
+
+# Optional: File Storage (defaults to ~/.tyler/files)
+NARRATOR_FILE_STORAGE_PATH=/data/files
+```
+
+### 3. Create Your Bot
+
+```python
+import asyncio
+from space_monkey import SlackApp, ThreadStore, FileStore, Agent
+
+async def main():
+    # Create stores
+    thread_store = await ThreadStore.create()  # In-memory by default
+    file_store = await FileStore.create()      # Default file storage
+    
+    # Create your agent
+    agent = Agent(
+        name="SlackBot",
+        model_name="gpt-4.1", 
+        purpose="To be a helpful assistant in Slack",
+        tools=["web", "files"],
+        temperature=0.7
+    )
+    
+    # Start the Slack app
+    app = SlackApp(
+        agent=agent,
+        thread_store=thread_store,
+        file_store=file_store
+    )
+    
+    await app.start()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+That's it! Your Tyler agent is now running as a Slack bot.
+
+## Advanced Configuration
+
+### Database Storage
+
+For production deployments, use a persistent database:
+
+```python
+from space_monkey import ThreadStore, FileStore
+
+# PostgreSQL
+thread_store = await ThreadStore.create(
+    "postgresql+asyncpg://user:pass@localhost/db"
+)
+
+# SQLite
+thread_store = await ThreadStore.create(
+    "sqlite+aiosqlite:///path/to/db.sqlite"
+)
+
+# Custom file storage
+file_store = await FileStore.create(
+    base_path="/data/files",
+    max_file_size=100 * 1024 * 1024,  # 100MB
+    max_storage_size=10 * 1024 * 1024 * 1024  # 10GB
+)
+```
+
+### Custom Agent Configuration
+
+```python
+# Create a custom agent with specific tools and settings
+agent = Agent(
+    name="CustomBot",
+    model_name="gpt-4.1",
+    purpose="Your custom agent purpose",
+    tools=["notion:notion-search", "web", "files"],
+    temperature=0.7,
+    version="1.0.0"
+)
+
+# Tyler Agent with custom settings
+agent = Agent(
+    name="CustomBot", 
+    model_name="gpt-4.1",
+    purpose="Your custom agent purpose",
+    tools=["notion:notion-search"],
+    temperature=0.5
+)
+```
+
+### App Configuration
+
+```python
+app = SlackApp(
+    agent=agent,
+    thread_store=thread_store,
+    file_store=file_store,
+    health_check_url="http://healthcheck:8000/ping-receiver",
+    weave_project="my-slack-bot"
+)
+
+# Start with custom host/port
+await app.start(host="0.0.0.0", port=8080)
+```
+
+## Agent Configuration
+
+Space Monkey uses Tyler Agent directly, giving you full access to all Tyler's capabilities:
+
+```python
+agent = Agent(
+    name="MyBot",             # Agent name
+    model_name="gpt-4.1",     # Model to use
+    purpose="Your agent's purpose and instructions",
+    tools=["web", "files"],   # Available tools
+    temperature=0.7,          # Model temperature
+    version="1.0.0"           # Agent version
+)
+```
+
+You can configure agents for any use case by adjusting the purpose and tools:
+- HR/People assistance with Notion integration
+- Customer support with web search
+- Technical assistance with file processing
+- And any other conversational AI use case
+
+## Message Routing
+
+Tyler Slack Bot automatically handles intelligent message routing:
+
+1. **Direct Messages**: All DM messages are processed by your agent
+2. **@Mentions**: Messages that mention the bot are always processed
+3. **Channel Messages**: Automatically classified to determine if they need a response
+4. **Thread Replies**: Continues conversations in threads appropriately
+5. **Reactions**: Simple acknowledgments get emoji reactions instead of text responses
+
+This happens automatically - you just define your agent's behavior and the bot handles the rest.
+
+## Storage Backends
+
+### Thread Storage
+
+- **In-Memory**: Fast, ephemeral (default for development)
+- **SQLite**: Local persistence (good for single-instance deployments)
+- **PostgreSQL**: Production-ready with full ACID compliance
+
+### File Storage
+
+- **Local File System**: Sharded directory structure for efficient file organization
+- **Configurable Limits**: Set maximum file sizes and total storage limits
+- **MIME Type Validation**: Automatic file type detection and validation
+
+## Production Deployment
+
+### Docker
+
+```dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+COPY . .
+CMD ["python", "bot.py"]
+```
+
+### Environment Configuration
+
+```bash
+# Production .env
+SLACK_BOT_TOKEN=xoxb-prod-token
+SLACK_APP_TOKEN=xapp-prod-token
+
+# Database
+TYLER_DB_TYPE=postgresql
+TYLER_DB_USER=tyler_prod
+TYLER_DB_PASSWORD=secure_password
+TYLER_DB_HOST=db.example.com
+TYLER_DB_PORT=5432
+TYLER_DB_NAME=tyler_prod
+
+# File Storage
+TYLER_FILE_STORAGE_PATH=/data/files
+
+# Monitoring
+WANDB_API_KEY=prod-key
+WANDB_PROJECT=slack-bot-prod
+HEALTH_CHECK_URL=http://healthcheck:8000/ping-receiver
+```
+
+### Health Monitoring
+
+The bot includes built-in health check endpoints and optional external health monitoring:
+
+```python
+app = SlackApp(
+    agent=agent,
+    thread_store=thread_store,
+    file_store=file_store,
+    health_check_url="http://healthcheck:8000/ping-receiver"
+)
+```
+
+## API Reference
+
+### SlackApp
+
+```python
+class SlackApp:
+    def __init__(
+        self,
+        agent: Agent,
+        thread_store: ThreadStore,
+        file_store: FileStore,
+        health_check_url: Optional[str] = None,
+        weave_project: Optional[str] = None
+    ):
+        """Initialize Slack app with agent and stores."""
+        
+    async def start(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8000
+    ) -> None:
+        """Start the Slack bot app."""
+```
+
+### Agent
+
+```python
+class Agent:
+    def __init__(
+        self,
+        name: str,
+        model_name: str,
+        purpose: str,
+        tools: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        version: str = "1.0.0",
+        thread_store: Optional[ThreadStore] = None,
+        file_store: Optional[FileStore] = None
+    ):
+        """Create a Tyler agent with full configuration options."""
+```
+
+### Stores
+
+```python
+# ThreadStore
+thread_store = await ThreadStore.create()  # In-memory
+thread_store = await ThreadStore.create(database_url)  # Database
+
+# FileStore  
+file_store = await FileStore.create()  # Default settings
+file_store = await FileStore.create(
+    base_path="/path/to/files",
+    max_file_size=100 * 1024 * 1024,
+    max_storage_size=10 * 1024 * 1024 * 1024
+)
+```
+
+## Examples
+
+### Simple HR Bot
+
+```python
+import asyncio
+from space_monkey import SlackApp, Agent, ThreadStore, FileStore
+
+async def main():
+    # Simple setup for an HR assistant
+    thread_store = await ThreadStore.create()
+    file_store = await FileStore.create()
+    
+    agent = Agent(
+        name="HRBot",
+        model_name="gpt-4.1",
+        purpose="To help with HR and people team questions",
+        tools=["notion:notion-search"],
+        temperature=0.7
+    )
+    
+    app = SlackApp(
+        agent=agent,
+        thread_store=thread_store,
+        file_store=file_store
+    )
+    
+    await app.start()
+
+asyncio.run(main())
+```
+
+### Custom Agent with Database
+
+```python
+import asyncio
+from space_monkey import SlackApp, Agent, ThreadStore, FileStore
+
+async def main():
+    # Production setup with PostgreSQL
+    thread_store = await ThreadStore.create(
+        "postgresql+asyncpg://user:pass@localhost/db"
+    )
+    file_store = await FileStore.create(base_path="/data/files")
+    
+    # Custom agent
+    agent = Agent(
+        name="SupportBot",
+        model_name="gpt-4.1",
+        purpose="Help users with technical support questions",
+        tools=["web", "files"],
+        temperature=0.3
+    )
+    
+    app = SlackApp(
+        agent=agent,
+        thread_store=thread_store,
+        file_store=file_store,
+        weave_project="support-bot"
+    )
+    
+    await app.start(port=8080)
+
+asyncio.run(main())
+```
+
+## Contributing
+
+Tyler Slack Bot is part of the Tyler ecosystem. See the main Tyler documentation for information about contributing to the project.
+
+## License
+
+MIT License - see LICENSE file for details. 

slide_space_monkey-0.1.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+space_monkey/__init__.py,sha256=U0KBTXnV9ITv_kRCEUydQNOHeBeJBq41Jvknh9UAY88,407
+space_monkey/classifier.py,sha256=qJiW0cllmJdb9UvQi68cwJOEhhSJ3OeD52N6aCG8JQ8,1208
+space_monkey/slack_app.py,sha256=Uz0cQ1Xr8u1um_Y0QxTctR7rrS9Bn5T_t-fwh0AnO9U,23366
+slide_space_monkey-0.1.1.dist-info/METADATA,sha256=xe7DjQnyGO2igBSV6BZ1HZmGn7yNwGaW6kBokgqQ59M,10830
+slide_space_monkey-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+slide_space_monkey-0.1.1.dist-info/RECORD,,

slide_space_monkey-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

space_monkey/__init__.py

@@ -0,0 +1,23 @@
+"""
+Space Monkey - Tyler Slack Bot
+
+A simple, powerful way to deploy Tyler AI agents as Slack bots.
+"""
+
+# Re-export core components from other packages
+from narrator import ThreadStore, FileStore
+from tyler import Agent
+
+# Import our own classes
+from .slack_app import SlackApp
+
+# Version
+__version__ = "0.1.1"
+
+# Main exports
+__all__ = [
+    "SlackApp",
+    "Agent", 
+    "ThreadStore",
+    "FileStore"
+] 

space_monkey/classifier.py

@@ -0,0 +1,35 @@
+"""
+Message classifier for Space Monkey internal use
+"""
+import logging
+import weave
+from tyler import Agent
+
+logger = logging.getLogger(__name__)
+
+@weave.op()
+def initialize_message_classifier_agent(thread_store=None, file_store=None, model_name="gpt-4.1", purpose_prompt=None, bot_user_id=None):
+    """
+    Initialize and return a classifier agent that determines if/how the main agent should respond.
+    
+    Args:
+        thread_store: The thread store instance for the agent to use (optional)
+        file_store: The file store instance for the agent to use (optional)
+        model_name: The model to use for the agent (default: gpt-4.1)
+        purpose_prompt: The purpose prompt for the agent
+        bot_user_id: The Slack user ID of the bot (optional)
+        
+    Returns:
+        Agent: An initialized message classifier agent
+    """
+    message_classifier_agent = Agent(
+        name="MessageClassifier",
+        model_name=model_name,
+        version="2.0.0",
+        purpose=purpose_prompt.format(bot_user_id=bot_user_id),
+        thread_store=thread_store,
+        file_store=file_store
+    )
+    
+    logger.info("MessageClassifier agent initialized")
+    return message_classifier_agent 

space_monkey/slack_app.py

@@ -0,0 +1,576 @@
+"""
+SlackApp class for Slack App integration
+"""
+import os
+import asyncio
+import logging
+import copy
+import json
+import time
+import threading
+import requests
+import weave
+from contextlib import asynccontextmanager
+from dotenv import load_dotenv
+from slack_bolt.async_app import AsyncApp
+from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+
+from narrator import Thread, Message
+from tyler.tools.slack import generate_slack_blocks
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+class SlackApp:
+    """
+    Main SlackApp class that encapsulates all Slack integration logic.
+    
+    This class provides a clean interface for running Tyler agents as Slack bots
+    with intelligent message routing, thread management, and health monitoring.
+    """
+    
+    def __init__(
+        self,
+        agent,
+        thread_store,
+        file_store,
+        health_check_url: str = None,
+        weave_project: str = None
+    ):
+        """
+        Initialize SlackApp with agent and stores.
+        
+        Args:
+            agent: The main Tyler agent to handle conversations
+            thread_store: ThreadStore instance for conversation persistence
+            file_store: FileStore instance for file handling
+            health_check_url: Optional URL for health check pings
+            weave_project: Optional Weave project name for tracing
+        """
+        # Load environment variables
+        load_dotenv()
+        
+        # Store configuration
+        self.agent = agent
+        self.thread_store = thread_store
+        self.file_store = file_store
+        self.health_check_url = health_check_url or os.getenv("HEALTH_CHECK_URL")
+        self.weave_project = weave_project or os.getenv("WANDB_PROJECT")
+        
+        # Internal state
+        self.slack_app = None
+        self.socket_handler = None
+        self.bot_user_id = None
+        self.message_classifier_agent = None
+        self.health_thread = None
+        
+        # FastAPI app for server functionality
+        self.fastapi_app = FastAPI(
+            title="Space Monkey Slack Agent",
+            lifespan=self._lifespan
+        )
+        
+        # Add CORS middleware
+        self.fastapi_app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+    
+    @asynccontextmanager
+    async def _lifespan(self, app: FastAPI):
+        """FastAPI lifespan context manager for startup/shutdown logic."""
+        # Startup
+        await self._startup()
+        yield
+        # Shutdown
+        await self._shutdown()
+    
+    async def _startup(self):
+        """Initialize all components during startup."""
+        logger.info("Starting Space Monkey Slack Agent...")
+        
+        # Initialize Weave if configured
+        await self._init_weave()
+        
+        # Initialize Slack app and get bot user ID
+        await self._init_slack_app()
+        
+        # Initialize message classifier
+        await self._init_classifier()
+        
+        # Register event handlers
+        self._register_event_handlers()
+        
+        # Start Slack socket connection
+        await self._start_slack()
+        
+        # Start health monitoring
+        self._start_health_monitoring()
+        
+        logger.info("Space Monkey Slack Agent started successfully")
+    
+    async def _shutdown(self):
+        """Clean shutdown logic."""
+        logger.info("Shutting down Space Monkey Slack Agent...")
+        
+        if self.socket_handler:
+            await self.socket_handler.close_async()
+        
+        # Close database connections if available
+        if (self.thread_store and 
+            hasattr(self.thread_store, '_backend') and 
+            hasattr(self.thread_store._backend, 'engine')):
+            try:
+                await self.thread_store._backend.engine.dispose()
+                logger.info("Database connections closed")
+            except Exception as e:
+                logger.error(f"Error closing database connections: {e}")
+    
+    async def _init_weave(self):
+        """Initialize Weave monitoring if configured."""
+        try:
+            if os.getenv("WANDB_API_KEY") and self.weave_project:
+                weave.init(self.weave_project)
+                logger.info("Weave tracing initialized successfully")
+        except Exception as e:
+            logger.warning(f"Failed to initialize weave tracing: {e}")
+    
+    async def _init_slack_app(self):
+        """Initialize the Slack app and get bot user ID."""
+        # Create Slack app
+        self.slack_app = AsyncApp(token=os.environ["SLACK_BOT_TOKEN"])
+        
+        # Get bot user ID for mention detection
+        auth_response = await self.slack_app.client.auth_test()
+        self.bot_user_id = auth_response["user_id"]
+        logger.info(f"Agent initialized with user ID: {self.bot_user_id}")
+    
+    async def _init_classifier(self):
+        """Initialize the message classifier agent."""
+        # Import here to avoid circular imports
+        from .classifier import initialize_message_classifier_agent
+        
+        # Get classifier prompt version from environment
+        classifier_prompt_version = os.getenv("MESSAGE_CLASSIFIER_PROMPT_VERSION")
+        if not classifier_prompt_version:
+            logger.error("MESSAGE_CLASSIFIER_PROMPT_VERSION not set")
+            raise RuntimeError("MESSAGE_CLASSIFIER_PROMPT_VERSION not set")
+        
+        # Fetch prompt from Weave
+        try:
+            classifier_prompt_obj = weave.ref(f"MessageClassifierPurposePrompt:{classifier_prompt_version}").get()
+            logger.info(f"Fetched classifier prompt: {classifier_prompt_version}")
+        except Exception as e:
+            logger.error(f"Failed to load classifier prompt: {e}")
+            raise RuntimeError(f"Failed to load classifier prompt: {e}")
+        
+        # Initialize classifier agent
+        self.message_classifier_agent = initialize_message_classifier_agent(
+            model_name="gpt-4.1",
+            purpose_prompt=classifier_prompt_obj,
+            thread_store=self.thread_store,
+            file_store=self.file_store,
+            bot_user_id=self.bot_user_id
+        )
+        logger.info("Message classifier agent initialized")
+    
+    def _register_event_handlers(self):
+        """Register Slack event handlers."""
+        # Global middleware for logging
+        @self.slack_app.use
+        async def log_all_events(client, context, logger, payload, next):
+            try:
+                logger.info(f"MIDDLEWARE: Received payload: {list(payload.keys())}")
+                if isinstance(payload, dict) and "type" in payload:
+                    event_type = payload["type"]
+                    logger.critical(f"MIDDLEWARE: Event type '{event_type}'")
+                    
+                    if event_type in ["reaction_added", "reaction_removed"]:
+                        logger.critical(f"MIDDLEWARE: REACTION EVENT: {json.dumps(payload)}")
+                    elif event_type == "message":
+                        logger.critical(f"MIDDLEWARE: MESSAGE EVENT: channel={payload.get('channel')}, user={payload.get('user')}, ts={payload.get('ts')}")
+                
+                await next()
+            except Exception as e:
+                logger.error(f"Error in middleware: {str(e)}")
+                await next()
+        
+        # Register event handlers
+        self.slack_app.event({"type": "message", "subtype": None})(self._handle_user_message)
+        self.slack_app.event("app_mention")(self._handle_app_mention)
+        self.slack_app.event("reaction_added")(self._handle_reaction_added)
+        self.slack_app.event("reaction_removed")(self._handle_reaction_removed)
+    
+    async def _start_slack(self):
+        """Start the Slack socket connection."""
+        self.socket_handler = AsyncSocketModeHandler(self.slack_app, os.environ["SLACK_APP_TOKEN"])
+        await self.socket_handler.start_async()
+        logger.info("Slack socket connection established")
+    
+    def _start_health_monitoring(self):
+        """Start health monitoring thread if configured."""
+        if not self.health_check_url:
+            return
+        
+        def health_ping_loop():
+            """Health ping loop in background thread."""
+            ping_interval = int(os.getenv("HEALTH_PING_INTERVAL_SECONDS", "120"))
+            logger.info(f"Starting health ping to {self.health_check_url} every {ping_interval}s")
+            
+            while True:
+                try:
+                    response = requests.get(self.health_check_url, timeout=5)
+                    if response.status_code == 200:
+                        logger.info(f"Health ping successful: {response.text}")
+                    else:
+                        logger.warning(f"Health ping returned status: {response.status_code}")
+                except Exception as e:
+                    logger.error(f"Health ping failed: {str(e)}")
+                
+                time.sleep(ping_interval)
+        
+        self.health_thread = threading.Thread(target=health_ping_loop, daemon=True)
+        self.health_thread.start()
+        logger.info("Health monitoring started")
+    
+    # Event handlers
+    async def _handle_app_mention(self, event, say):
+        """Handle app mention events."""
+        logger.info(f"App mention event: ts={event.get('ts')}")
+    
+    async def _handle_user_message(self, event, say):
+        """Handle user messages with intelligent routing."""
+        ts = event.get("ts")
+        thread_ts = event.get("thread_ts")
+        channel = event.get("channel")
+        channel_type = event.get("channel_type")
+        
+        logger.info(f"Message: ts={ts}, thread_ts={thread_ts}, channel={channel}, type={channel_type}")
+        
+        # Check if message should be processed
+        if not await self._should_process_message(event):
+            logger.info("Skipping message processing")
+            return
+        
+        text = event.get("text", "")
+        
+        # Process the message
+        response_type, content = await self._process_message(text, event)
+        
+        # Handle different response types
+        if response_type == "none":
+            logger.info("No response needed")
+            return
+        elif response_type == "emoji":
+            await self._send_emoji_reaction(content)
+        elif response_type == "message":
+            await self._send_text_response(content, event, say)
+        else:
+            logger.warning(f"Unknown response type: {response_type}")
+    
+    async def _handle_reaction_added(self, event, say):
+        """Handle reaction added events."""
+        try:
+            user = event.get("user")
+            emoji = event.get("reaction")
+            item_ts = event.get("item", {}).get("ts")
+            
+            logger.info(f"Reaction added: {emoji} by {user} on {item_ts}")
+            
+            # Find message and thread
+            message, thread = await self._find_message_and_thread(item_ts)
+            if message and thread:
+                if thread.add_reaction(message.id, emoji, user):
+                    await self.thread_store.save(thread)
+                    logger.info(f"Stored reaction {emoji}")
+        except Exception as e:
+            logger.error(f"Error handling reaction: {str(e)}")
+    
+    async def _handle_reaction_removed(self, event, say):
+        """Handle reaction removed events."""
+        try:
+            user = event.get("user")
+            emoji = event.get("reaction")
+            item_ts = event.get("item", {}).get("ts")
+            
+            logger.info(f"Reaction removed: {emoji} by {user} on {item_ts}")
+            
+            # Find message and thread
+            message, thread = await self._find_message_and_thread(item_ts)
+            if message and thread:
+                if thread.remove_reaction(message.id, emoji, user):
+                    await self.thread_store.save(thread)
+                    logger.info(f"Removed reaction {emoji}")
+        except Exception as e:
+            logger.error(f"Error handling reaction removal: {str(e)}")
+    
+    # Helper methods
+    async def _should_process_message(self, event):
+        """Determine if a message should be processed."""
+        ts = str(event.get("ts"))
+        channel_type = event.get("channel_type")
+        thread_ts = event.get("thread_ts")
+        
+        # Check if already processed
+        try:
+            messages = await self.thread_store.find_messages_by_attribute("platforms.slack.ts", ts)
+            if messages:
+                logger.info(f"Message {ts} already processed")
+                return False
+        except Exception as e:
+            logger.warning(f"Error checking message: {str(e)}")
+        
+        # Process DMs, threaded messages, and channel messages
+        if channel_type == "im" or thread_ts:
+            return True
+        
+        return True  # For now, process all channel messages
+    
+    async def _process_message(self, text: str, event: dict):
+        """Process a message and return (type, content) tuple."""
+        try:
+            # Get or create thread
+            thread = await self._get_or_create_thread(event)
+            
+            # Create user message
+            user_id = event.get("user", "unknown_user")
+            user_message = Message(
+                role="user",
+                content=text,
+                source={"id": user_id, "type": "user"},
+                platforms={
+                    "slack": {
+                        "channel": event.get("channel"),
+                        "ts": event.get("ts"),
+                        "thread_ts": event.get("thread_ts") or event.get("ts")
+                    }
+                }
+            )
+            
+            # Add message to thread and save
+            thread.add_message(user_message)
+            await self.thread_store.save(thread)
+            
+            # Run message classifier
+            classifier_thread = copy.deepcopy(thread)
+            thread_ts = event.get("thread_ts") or event.get("ts")
+            
+            with weave.attributes({'env': os.getenv("ENV", "development"), 'event_id': thread_ts}):
+                _, classify_messages = await self.message_classifier_agent.go(classifier_thread)
+            
+            # Parse classification result
+            classify_result = classify_messages[-1].content if classify_messages else None
+            if classify_result:
+                try:
+                    classification = json.loads(classify_result)
+                    response_type = classification.get("response_type", "full_response")
+                    
+                    if response_type == "ignore":
+                        logger.info(f"Classification: IGNORE - {classification.get('reasoning', '')}")
+                        return ("none", "")
+                    elif response_type == "emoji_reaction":
+                        emoji = classification.get("suggested_emoji", "thumbsup")
+                        logger.info(f"Classification: EMOJI ({emoji}) - {classification.get('reasoning', '')}")
+                        return ("emoji", {
+                            "ts": event.get("ts"),
+                            "channel": event.get("channel"),
+                            "emoji": emoji
+                        })
+                except json.JSONDecodeError:
+                    logger.warning(f"Failed to parse classification: {classify_result}")
+            
+            # Add thinking emoji while processing
+            try:
+                await self.slack_app.client.reactions_add(
+                    channel=event.get("channel"),
+                    timestamp=event.get("ts"),
+                    name="thinking_face"
+                )
+            except Exception as e:
+                logger.warning(f"Failed to add thinking emoji: {str(e)}")
+            
+            # Process with main agent
+            with weave.attributes({'env': os.getenv("ENV", "development"), 'event_id': thread_ts}):
+                _, new_messages = await self.agent.go(thread.id)
+            
+            # Get assistant response
+            assistant_messages = [m for m in new_messages if m.role == "assistant"]
+            assistant_message = assistant_messages[-1] if assistant_messages else None
+            
+            if not assistant_message:
+                return ("message", "I apologize, but I couldn't generate a response.")
+            
+            response_content = assistant_message.content
+            
+            # Add dev footer if metrics available
+            if hasattr(assistant_message, 'metrics') and assistant_message.metrics:
+                footer = self._get_dev_footer(assistant_message.metrics)
+                if footer:
+                    response_content += footer
+            
+            return ("message", response_content)
+            
+        except Exception as e:
+            logger.error(f"Error processing message: {e}", exc_info=True)
+            return ("message", f"I apologize, but I encountered an error: {str(e)}")
+    
+    async def _get_or_create_thread(self, event):
+        """Get or create a thread based on Slack event data."""
+        slack_platform_data = {
+            "channel": event.get("channel"),
+            "thread_ts": event.get("thread_ts") or event.get("ts"),
+        }
+        
+        # Try to find existing thread
+        if event.get("thread_ts"):
+            try:
+                threads = await self.thread_store.find_by_platform("slack", {"thread_ts": str(event.get("thread_ts"))})
+                if threads:
+                    return threads[0]
+            except Exception as e:
+                logger.warning(f"Error finding thread: {str(e)}")
+        
+        # Try by ts
+        ts = event.get("ts")
+        if ts:
+            try:
+                threads = await self.thread_store.find_by_platform("slack", {"thread_ts": str(ts)})
+                if threads:
+                    return threads[0]
+            except Exception as e:
+                logger.warning(f"Error finding thread by ts: {str(e)}")
+        
+        # Create new thread
+        thread = Thread(platforms={"slack": slack_platform_data})
+        await self.thread_store.save(thread)
+        logger.info(f"Created new thread {thread.id}")
+        return thread
+    
+    async def _find_message_and_thread(self, item_ts):
+        """Find a message and its thread by timestamp."""
+        try:
+            messages = await self.thread_store.find_messages_by_attribute("platforms.slack.ts", item_ts)
+            if not messages:
+                return None, None
+            
+            message = messages[0]
+            thread = await self.thread_store.get_thread_by_message_id(message.id)
+            return message, thread
+        except Exception as e:
+            logger.error(f"Error finding message: {str(e)}")
+            return None, None
+    
+    async def _send_emoji_reaction(self, reaction_info):
+        """Send an emoji reaction."""
+        try:
+            await self.slack_app.client.reactions_add(
+                channel=reaction_info["channel"],
+                timestamp=reaction_info["ts"],
+                name=reaction_info["emoji"]
+            )
+        except Exception as e:
+            logger.error(f"Error sending emoji reaction: {str(e)}")
+    
+    async def _send_text_response(self, text, event, say):
+        """Send a text response."""
+        try:
+            # Convert to Slack blocks
+            thread_ts = event.get("thread_ts") or event.get("ts")
+            response_blocks = await self._convert_to_slack_blocks(text, thread_ts)
+            
+            # Send response
+            response = await say(
+                thread_ts=thread_ts,
+                text=response_blocks["text"],
+                blocks=response_blocks["blocks"]
+            )
+            
+            # Update assistant message with Slack timestamp
+            if response and "ts" in response:
+                thread = await self._get_or_create_thread(event)
+                await self._update_assistant_message_with_slack_ts(
+                    thread,
+                    event.get("channel"),
+                    response["ts"],
+                    thread_ts
+                )
+        except Exception as e:
+            logger.error(f"Error sending text response: {str(e)}")
+    
+    async def _convert_to_slack_blocks(self, text, thread_ts=None):
+        """Convert markdown text to Slack blocks."""
+        try:
+            with weave.attributes({'env': os.getenv("ENV", "development"), 'event_id': thread_ts}):
+                result = await generate_slack_blocks(content=text)
+            
+            if result and isinstance(result, dict) and "blocks" in result:
+                return {"blocks": result["blocks"], "text": result.get("text", text)}
+            else:
+                return {"text": text}
+        except Exception as e:
+            logger.error(f"Error converting to Slack blocks: {e}")
+            return {"text": text}
+    
+    async def _update_assistant_message_with_slack_ts(self, thread, channel, response_ts, thread_ts):
+        """Update assistant message with Slack timestamp."""
+        try:
+            for message in reversed(thread.messages):
+                if message.role == "assistant" and (not message.platforms or "slack" not in message.platforms):
+                    message.platforms = message.platforms or {}
+                    message.platforms["slack"] = {
+                        "channel": channel,
+                        "ts": response_ts,
+                        "thread_ts": thread_ts
+                    }
+                    await self.thread_store.save(thread)
+                    logger.info(f"Updated assistant message with ts={response_ts}")
+                    return True
+            return False
+        except Exception as e:
+            logger.error(f"Error updating assistant message: {str(e)}")
+            return False
+    
+    def _get_dev_footer(self, metrics):
+        """Generate dev footer from metrics."""
+        footer = f"\n\n{self.agent.name}: v{getattr(self.agent, 'version', '1.0.0')}"
+        
+        model = metrics.get('model', 'N/A')
+        weave_url = None
+        if 'weave_call' in metrics:
+            weave_url = metrics['weave_call'].get('ui_url')
+        
+        if model:
+            footer += f" {model}"
+        if weave_url:
+            footer += f" | [Weave trace]({weave_url})"
+        
+        return footer if (weave_url or model) else ""
+    
+    async def start(self, host: str = "0.0.0.0", port: int = 8000):
+        """Start the Slack bot server."""
+        config = uvicorn.Config(
+            app=self.fastapi_app,
+            host=host,
+            port=port,
+            log_level="info",
+            workers=1,
+            loop="asyncio",
+            timeout_keep_alive=65,
+        )
+        
+        server = uvicorn.Server(config)
+        
+        try:
+            logger.info(f"Starting server on {host}:{port}")
+            await server.serve()
+        except Exception as e:
+            logger.error(f"Server error: {str(e)}", exc_info=True)
+            raise
+        finally:
+            logger.info("Server shutting down")