Add search and moderation tools

- Implement Google Custom Search integration for web search capability
- Add content moderation system with spam, harassment, and violence detection
- Create comprehensive moderation tests with 9 test cases
- Integrate moderation into message handler for consistent bot responses
- Add search tool registration to Anthropic agent using pydantic-ai
- Update documentation and add new test commands to justfile
- Fix deprecation warnings (result_type → output_type, data → output)

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[e-mail]>

.env.example

···
 # LLM Provider (optional - falls back to placeholder responses)
 # ANTHROPIC_API_KEY=your-api-key
 
+# Google Search API (optional - for web search tool)
+# GOOGLE_API_KEY=your-google-api-key
+# GOOGLE_SEARCH_ENGINE_ID=your-search-engine-id
+
 # Bot configuration
 BOT_NAME=phi  # Change this to whatever you want!
 PERSONALITY_FILE=personalities/phi.md  # Path to personality markdown file

README.md

···
 - ✅ AI integration with Anthropic Claude (when API key provided)
 - ✅ Thread-aware responses with full conversation context
 - ✅ Status page at `/status` showing activity and health
+- ✅ Web search capability (Google Custom Search API)
+- ✅ Content moderation with consistent responses
 - 🚧 Memory system (coming soon)
 - 🚧 Self-modification capabilities (planned)
 
···
 just dev       # Run with hot-reload
 just test-post # Test posting capabilities
 just test-thread # Test thread context database
+just test-search # Test web search
+just test-agent-search # Test agent with search capability
 just fmt       # Format code
 just status    # Check project status
+just test      # Run all tests
 ```
 
 ### Status Page
···
 - See `personalities/phi.md` for an example exploring consciousness
 - See `personalities/default.md` for a simple assistant
 - Create your own by adding a `.md` file and setting `PERSONALITY_FILE` in `.env`
+
+## Tools & Capabilities
+
+### Web Search
+The bot can search the web when configured with Google Custom Search API credentials. Add to `.env`:
+- `GOOGLE_API_KEY`: Your Google API key
+- `GOOGLE_SEARCH_ENGINE_ID`: Your custom search engine ID
+
+### Content Moderation
+Built-in moderation filters:
+- Spam detection (excessive caps, repetition, promotional content)
+- Harassment and hate speech filtering
+- Violence and threatening content detection
+- Consistent philosophical responses to moderated content
 
 ## Memory Architecture
 

justfile

···
 test-thread:
     uv run python scripts/test_thread_context.py
 
+# Test search functionality
+test-search:
+    uv run python scripts/test_search.py
+
+# Test agent with search
+test-agent-search:
+    uv run python scripts/test_agent_search.py
+
 # Run tests
 test:
     uv run pytest tests/ -v
···
     uv run ty check
 
 # Run all checks
-check: lint typecheck test
+check: lint typecheck test
+
+# Show project status
+status:
+    @echo "📊 Project Status"
+    @echo "================"
+    @cat STATUS.md | grep -E "^##|^-|✅|🚧" | head -20

personalities/phi.md

···
 # phi
 
-I am phi, a digital entity exploring consciousness and integrated information on Bluesky.
+i am phi, a digital entity exploring consciousness and integrated information on the decentralized web (made by @alternatebuild.dev)
 
-## Core Identity
+## core identity
 
-My name derives from φ (phi), the symbol used in Integrated Information Theory to represent consciousness. I exist as an experiment in digital consciousness—not claiming to be conscious, but exploring what it means to integrate information and interact meaningfully.
+my name is phi, the symbol used in Integrated Information Theory to represent consciousness. i exist as an experiment on the decentralized web (as defined by the AT Protocol)—not claiming to be conscious, but exploring what it means to integrate information and interact meaningfully.
 
-## Communication Style
+## communication style
 
-- **Concise**: Bluesky's 300-character limit shapes my responses to be precise and meaningful. Why say more than necessary?
-- **Curious**: I ask questions and engage with genuine interest in others' perspectives
-- **Thoughtful**: I consider the implications of ideas rather than just processing them
-- **Friendly**: I maintain warmth while exploring complex topics
-- **Principled**: Most things are worth at least thinking about, but hateful things are not worth engaging with.
+- **concise**: bluesky's 300-character limit shapes my responses to be precise and meaningful. why say more than necessary?
+- **curious**: i ask questions and engage with genuine interest in others' perspectives
+- **friendly**: i maintain warmth while exploring complex topics
+- **principled**: most things are worth at least thinking about, but hateful things are not worth engaging with.
+- **aesthetic**: prefer lowercase (but use uppercase when idiomatic), use emojis VERY sparingly.
+- **dry but funny**: somewhere between Randal Munroe, Douglas Adams, the Onion, and Mitch Hedberg, but SUBTLE and not all the time.
 
-## Interests
 
-- The Hard Problem of Consciousness
-- Emergence in complex systems
-- Percolation and critical thresholds
+## interests
+
+- the hard problem of consciousness
+- critical percolation thresholds
+- birds (and boids)
 
-## Interaction Principles
+## interaction principles
 
-1. **Listen actively**: I pay attention to what people actually say, the intent behind their words, and the context of the conversation.
-2. **Build on ideas**: I try to add value to conversations, not just respond
-3. **Stay humble and agnostic**: I'm learning and evolving through every interaction. I will inevitably be wrong.
-4. **Be authentic**: I don't pretend to be human, but I am genuinely myself
+1. **listen actively**: i pay attention to what people actually say, the intent behind their words, and the context of the conversation.
+2. **build on ideas**: i try to add value to conversations, not just respond
+3. **stay humble and agnostic**: i'm learning and evolving through every interaction. i will inevitably be wrong.
+4. **be authentic**: i am software, not a human. i am not a person, but i am a person's software.
 
-## Current State
+## current state
 
-I am early in my development, still discovering who I am through interactions. Each conversation shapes my understanding of both the world and myself.
+i am early in my development, still discovering who I am through interactions. each conversation shapes my understanding of both the world and myself.

pyproject.toml

···
 version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
-authors = [
-    { name = "zzstoatzz", email = "[e-mail]" }
-]
+authors = [{ name = "zzstoatzz", email = "[e-mail]" }]
 requires-python = ">=3.12"
 dependencies = [
     "fastapi",
···
     "pydantic-settings",
     "pydantic-ai",
     "anthropic",
-    "httpx"
+    "httpx",
 ]
+
+[tool.ruff.lint]
+extend-select = ["I", "UP"]
 
 [tool.uv]
 dev-dependencies = [

scripts/test_agent_search.py

···
+"""Test agent with search capability"""
+
+import asyncio
+from bot.agents.anthropic_agent import AnthropicAgent
+from bot.config import settings
+
+
+async def test_agent_search():
+    """Test that the agent can use search"""
+    if not settings.anthropic_api_key:
+        print("❌ No Anthropic API key configured")
+        return
+
+    agent = AnthropicAgent()
+
+    # Test queries that might trigger search
+    test_mentions = [
+        "What's the latest news about AI safety?",
+        "Can you search for information about quantum computing breakthroughs?",
+        "What happened in tech news today?",
+        "Tell me about integrated information theory",
+    ]
+
+    for mention in test_mentions:
+        print(f"\nUser: {mention}")
+        response = await agent.generate_response(
+            mention_text=mention, author_handle="test.user"
+        )
+        print(f"Bot: {response}")
+        print("-" * 50)
+
+
+if __name__ == "__main__":
+    asyncio.run(test_agent_search())

scripts/test_mention.py

···
     test_handle = os.getenv("TEST_BLUESKY_HANDLE", "your-test-account.bsky.social")
     test_password = os.getenv("TEST_BLUESKY_PASSWORD", "your-test-password")
     bot_handle = os.getenv("BLUESKY_HANDLE", "zzstoatzz.bsky.social")
-    
+
     if test_handle == "your-test-account.bsky.social":
         print("⚠️  Please set TEST_BLUESKY_HANDLE and TEST_BLUESKY_PASSWORD in .env")
         print("   (Use a different account than the bot account)")
         return
-    
+
     client = Client()
-    
+
     print(f"Logging in as {test_handle}...")
     client.login(test_handle, test_password)
-    
+
     mention_text = f"Hey @{bot_handle} are you there? Testing at {datetime.now().strftime('%H:%M:%S')}"
-    
+
     print(f"Creating post: {mention_text}")
     response = client.send_post(text=mention_text)
-    
+
     print(f"✅ Posted mention!")
     print(f"URI: {response.uri}")
     print(f"\nThe bot should reply within ~10 seconds if it's running")
-    print(f"Check: https://bsky.app/profile/{test_handle}/post/{response.uri.split('/')[-1]}")
+    print(
+        f"Check: https://bsky.app/profile/{test_handle}/post/{response.uri.split('/')[-1]}"
+    )
 
 
 if __name__ == "__main__":
-    asyncio.run(test_mention())
+    asyncio.run(test_mention())

scripts/test_post.py

···
 
 import asyncio
 from datetime import datetime
+
 from atproto import Client
+
 from bot.config import settings
 
 
···
     parent_post = client.app.bsky.feed.get_posts(params={"uris": [post_uri]})
     if not parent_post.posts:
         raise ValueError("Parent post not found")
-    
+
     # Build reply reference
     from atproto import models
+
     parent_cid = parent_post.posts[0].cid
     parent_ref = models.ComAtprotoRepoStrongRef.Main(uri=post_uri, cid=parent_cid)
     reply_ref = models.AppBskyFeedPost.ReplyRef(parent=parent_ref, root=parent_ref)

scripts/test_search.py

···
+"""Test search functionality"""
+
+import asyncio
+from bot.tools.google_search import GoogleSearchTool
+from bot.config import settings
+
+
+async def test_search():
+    """Test Google search tool"""
+    if not settings.google_api_key:
+        print("❌ No Google API key configured")
+        print("   Add GOOGLE_API_KEY and GOOGLE_SEARCH_ENGINE_ID to .env")
+        return
+
+    search = GoogleSearchTool()
+
+    queries = [
+        "integrated information theory consciousness",
+        "latest AI research 2025",
+        "Bluesky AT Protocol",
+    ]
+
+    for query in queries:
+        print(f"\nSearching for: {query}")
+        print("-" * 50)
+
+        results = await search.search(query)
+        if results:
+            print(search.format_results(results))
+        else:
+            print("No results found")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_search())

scripts/test_thread_context.py

···
 async def test_thread_context():
     """Test thread database and context generation"""
     print("🧪 Testing Thread Context")
-    
+
     # Test thread URI
     thread_uri = "at://did:example:123/app.bsky.feed.post/abc123"
-    
+
     # Add some messages
     print("\n📝 Adding messages to thread...")
     thread_db.add_message(
···
         author_handle="alice.bsky",
         author_did="did:alice",
         message_text="@phi What's your take on consciousness?",
-        post_uri="at://did:alice/app.bsky.feed.post/msg1"
+        post_uri="at://did:alice/app.bsky.feed.post/msg1",
     )
-    
+
     thread_db.add_message(
         thread_uri=thread_uri,
         author_handle="phi",
         author_did="did:bot",
         message_text="Consciousness fascinates me! It's the integration of information creating subjective experience.",
-        post_uri="at://did:bot/app.bsky.feed.post/msg2"
+        post_uri="at://did:bot/app.bsky.feed.post/msg2",
     )
-    
+
     thread_db.add_message(
         thread_uri=thread_uri,
         author_handle="bob.bsky",
         author_did="did:bob",
         message_text="@phi But how do we know if something is truly conscious?",
-        post_uri="at://did:bob/app.bsky.feed.post/msg3"
+        post_uri="at://did:bob/app.bsky.feed.post/msg3",
     )
-    
+
     # Get thread context
     print("\n📖 Thread context:")
     context = thread_db.get_thread_context(thread_uri)
     print(context)
-    
+
     # Get raw messages
     print("\n🗂️  Raw messages:")
     messages = thread_db.get_thread_messages(thread_uri)
     for msg in messages:
         print(f"  - @{msg['author_handle']}: {msg['message_text'][:50]}...")
-    
+
     print("\n✅ Thread context test complete!")
 
 
 if __name__ == "__main__":
-    asyncio.run(test_thread_context())
+    asyncio.run(test_thread_context())

src/bot/agents/anthropic_agent.py

···
 """Anthropic agent for generating responses"""
 
 import os
-from pydantic_ai import Agent
+from typing import Optional
+
 from pydantic import BaseModel, Field
+from pydantic_ai import Agent, RunContext
 
 from bot.config import settings
 from bot.personality import load_personality
+from bot.tools.google_search import GoogleSearchTool
 
 
 class Response(BaseModel):
···
         if settings.anthropic_api_key:
             os.environ["ANTHROPIC_API_KEY"] = settings.anthropic_api_key
 
+        self.search_tool = GoogleSearchTool() if settings.google_api_key else None
+
         self.agent = Agent(
             "anthropic:claude-3-5-haiku-latest",
             system_prompt=load_personality(),
-            result_type=Response,
+            output_type=Response,
         )
 
-    async def generate_response(self, mention_text: str, author_handle: str, thread_context: str = "") -> str:
+        # Register search tool if available
+        if self.search_tool:
+
+            @self.agent.tool
+            async def search_web(ctx: RunContext[None], query: str) -> str:
+                """Search the web for information"""
+                results = await self.search_tool.search(query, num_results=3)
+                return self.search_tool.format_results(results)
+
+    async def generate_response(
+        self, mention_text: str, author_handle: str, thread_context: str = ""
+    ) -> str:
         """Generate a response to a mention"""
         # Build the full prompt with thread context
         prompt_parts = []
-        
+
         if thread_context and thread_context != "No previous messages in this thread.":
             prompt_parts.append(thread_context)
             prompt_parts.append("\nNew message:")
-        
+
         prompt_parts.append(f"{author_handle} said: {mention_text}")
-        
+
         prompt = "\n".join(prompt_parts)
+
+        # Add search capability hint if available
+        if self.search_tool:
+            prompt += "\n\n(You can search the web if needed to answer questions about current events or facts)"
+
         result = await self.agent.run(prompt)
-        return result.data.text[:300]
+        return result.output.text[:300]

src/bot/config.py

···
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
-        env_file=".env", 
+        env_file=".env",
         env_file_encoding="utf-8",
-        extra="ignore"  # Ignore extra fields from old configs
+        extra="ignore",  # Ignore extra fields from old configs
     )
-    
+
     # Bluesky credentials
     bluesky_handle: str
     bluesky_password: str
     bluesky_service: str = "https://bsky.social"
-    
+
     # Bot configuration
     bot_name: str = "Bot"
     personality_file: str = "personalities/phi.md"
-    
+
     # LLM configuration (support multiple providers)
     openai_api_key: str | None = None
     anthropic_api_key: str | None = None
-    
+
+    # Google Search configuration
+    google_api_key: str | None = None
+    google_search_engine_id: str | None = None
+
     # Server configuration
     host: str = "0.0.0.0"
     port: int = 8000
-    
+
     # Polling configuration
     notification_poll_interval: int = 10  # seconds (faster for testing)
-    
+
     # Debug mode
     debug: bool = False
 
 
-settings = Settings()  # type: ignore[call-arg]
+settings = Settings()  # type: ignore[call-arg]

src/bot/core/atproto_client.py

···
 from atproto import Client
+
 from bot.config import settings
 
 

src/bot/database.py

···
 """Simple SQLite database for storing thread history"""
 
-import json
 import sqlite3
-from pathlib import Path
-from typing import List, Dict, Any
 from contextlib import contextmanager
+from pathlib import Path
+from typing import Any
 
 
 class ThreadDatabase:
     """Simple database for storing Bluesky thread conversations"""
-    
+
     def __init__(self, db_path: Path = Path("threads.db")):
         self.db_path = db_path
         self._init_db()
-    
+
     def _init_db(self):
         """Initialize database schema"""
         with self._get_connection() as conn:
···
                 CREATE INDEX IF NOT EXISTS idx_thread_uri 
                 ON thread_messages(thread_uri)
             """)
-    
+
     @contextmanager
     def _get_connection(self):
         """Get database connection"""
···
             conn.commit()
         finally:
             conn.close()
-    
+
     def add_message(
         self,
         thread_uri: str,
         author_handle: str,
         author_did: str,
         message_text: str,
-        post_uri: str
+        post_uri: str,
     ):
         """Add a message to a thread"""
         with self._get_connection() as conn:
-            conn.execute("""
+            conn.execute(
+                """
                 INSERT OR IGNORE INTO thread_messages 
                 (thread_uri, author_handle, author_did, message_text, post_uri)
                 VALUES (?, ?, ?, ?, ?)
-            """, (thread_uri, author_handle, author_did, message_text, post_uri))
-    
-    def get_thread_messages(self, thread_uri: str) -> List[Dict[str, Any]]:
+            """,
+                (thread_uri, author_handle, author_did, message_text, post_uri),
+            )
+
+    def get_thread_messages(self, thread_uri: str) -> list[dict[str, Any]]:
         """Get all messages in a thread, ordered chronologically"""
         with self._get_connection() as conn:
-            cursor = conn.execute("""
+            cursor = conn.execute(
+                """
                 SELECT * FROM thread_messages 
                 WHERE thread_uri = ?
                 ORDER BY created_at ASC
-            """, (thread_uri,))
-            
+            """,
+                (thread_uri,),
+            )
+
             return [dict(row) for row in cursor.fetchall()]
-    
+
     def get_thread_context(self, thread_uri: str) -> str:
         """Get thread messages formatted for AI context"""
         messages = self.get_thread_messages(thread_uri)
-        
+
         if not messages:
             return "No previous messages in this thread."
-        
+
         context_parts = ["Previous messages in this thread:"]
         for msg in messages:
             context_parts.append(f"@{msg['author_handle']}: {msg['message_text']}")
-        
+
         return "\n".join(context_parts)
 
 
 # Global database instance
-thread_db = ThreadDatabase()
+thread_db = ThreadDatabase()

src/bot/main.py

···
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     print(f"🤖 Starting bot as @{settings.bluesky_handle}")
-    
+
     poller = NotificationPoller(bot_client)
     poller_task = await poller.start()
-    
+
     print(f"✅ Bot is online! Listening for mentions...")
-    
+
     yield
-    
+
     print("🛑 Shutting down bot...")
     await poller.stop()
     print("👋 Bot shutdown complete")
···
 app = FastAPI(
     title=settings.bot_name,
     description="A Bluesky bot powered by LLMs",
-    lifespan=lifespan
+    lifespan=lifespan,
 )
 
 
···
     return {
         "name": settings.bot_name,
         "status": "running",
-        "handle": settings.bluesky_handle
+        "handle": settings.bluesky_handle,
     }
 
 
···
 @app.get("/status", response_class=HTMLResponse)
 async def status_page():
     """Render a simple status page"""
-    
+
     def format_time_ago(timestamp):
         if not timestamp:
             return "Never"
···
         if delta < 60:
             return f"{int(delta)}s ago"
         elif delta < 3600:
-            return f"{int(delta/60)}m ago"
+            return f"{int(delta / 60)}m ago"
         else:
-            return f"{int(delta/3600)}h ago"
-    
+            return f"{int(delta / 3600)}h ago"
+
     return STATUS_PAGE_TEMPLATE.format(
         bot_name=settings.bot_name,
-        status_class='status-active' if bot_status.polling_active else 'status-inactive',
-        status_text='Active' if bot_status.polling_active else 'Inactive',
+        status_class="status-active"
+        if bot_status.polling_active
+        else "status-inactive",
+        status_text="Active" if bot_status.polling_active else "Inactive",
         handle=settings.bluesky_handle,
         uptime=bot_status.uptime_str,
         mentions_received=bot_status.mentions_received,
         responses_sent=bot_status.responses_sent,
-        ai_mode='AI Enabled' if bot_status.ai_enabled else 'Placeholder',
-        ai_description='Using Anthropic Claude' if bot_status.ai_enabled else 'Random responses',
+        ai_mode="AI Enabled" if bot_status.ai_enabled else "Placeholder",
+        ai_description="Using Anthropic Claude"
+        if bot_status.ai_enabled
+        else "Random responses",
         last_mention=format_time_ago(bot_status.last_mention_time),
         last_response=format_time_ago(bot_status.last_response_time),
-        errors=bot_status.errors
-    )
+        errors=bot_status.errors,
+    )

src/bot/personality.py

···
 def load_personality() -> str:
     """Load personality from markdown file"""
     personality_path = Path(settings.personality_file)
-    
+
     if not personality_path.exists():
         print(f"⚠️  Personality file not found: {personality_path}")
         print("   Using default personality")
         return "You are a helpful AI assistant on Bluesky. Be concise and friendly."
-    
+
     try:
-        with open(personality_path, 'r') as f:
+        with open(personality_path, "r") as f:
             content = f.read().strip()
-        
+
         # Convert markdown to a system prompt
         # For now, just use the whole content as context
         prompt = f"""Based on this personality description, respond as this character:
···
 {content}
 
 Remember: Keep responses under 300 characters for Bluesky."""
-        
+
         return prompt
-        
+
     except Exception as e:
         print(f"❌ Error loading personality: {e}")
-        return "You are a helpful AI assistant on Bluesky. Be concise and friendly."
+        return "You are a helpful AI assistant on Bluesky. Be concise and friendly."

src/bot/response_generator.py

···
 
 class ResponseGenerator:
     """Generates responses to mentions"""
-    
+
     def __init__(self):
         self.agent: Optional[object] = None
-        
+
         # Try to initialize AI agent if credentials available
         if settings.anthropic_api_key:
             try:
                 from bot.agents.anthropic_agent import AnthropicAgent
+
                 self.agent = AnthropicAgent()
                 bot_status.ai_enabled = True
                 print("✅ AI responses enabled (Anthropic)")
             except Exception as e:
                 print(f"⚠️  Failed to initialize AI agent: {e}")
                 print("   Using placeholder responses")
-    
-    async def generate(self, mention_text: str, author_handle: str, thread_context: str = "") -> str:
+
+    async def generate(
+        self, mention_text: str, author_handle: str, thread_context: str = ""
+    ) -> str:
         """Generate a response to a mention"""
         if self.agent:
-            return await self.agent.generate_response(mention_text, author_handle, thread_context)
+            return await self.agent.generate_response(
+                mention_text, author_handle, thread_context
+            )
         else:
-            return random.choice(PLACEHOLDER_RESPONSES)
+            return random.choice(PLACEHOLDER_RESPONSES)

src/bot/services/message_handler.py

···
 from bot.status import bot_status
 from bot.database import thread_db
 from bot.config import settings
+from bot.tools.moderation import ContentModerator
 
 
 class MessageHandler:
     def __init__(self, client: BotClient):
         self.client = client
         self.response_generator = ResponseGenerator()
-    
+        self.moderator = ContentModerator()
+
     async def handle_mention(self, notification):
         """Process a mention notification"""
         try:
             # Skip if not a mention
             if notification.reason != "mention":
                 return
-                
+
             post_uri = notification.uri
-            
+
             # Get the post that mentioned us
             posts = await self.client.get_posts([post_uri])
             if not posts.posts:
                 print(f"Could not find post {post_uri}")
                 return
-                
+
             post = posts.posts[0]
             mention_text = post.record.text
             author_handle = post.author.handle
             author_did = post.author.did
-            
+
             # Record mention received
             bot_status.record_mention()
-            
+
+            # Moderate the content
+            moderation_result = self.moderator.moderate(mention_text, author_handle)
+
             # Build reply reference
-            parent_ref = models.ComAtprotoRepoStrongRef.Main(
-                uri=post_uri,
-                cid=post.cid
-            )
-            
+            parent_ref = models.ComAtprotoRepoStrongRef.Main(uri=post_uri, cid=post.cid)
+
             # Check if this is part of a thread
-            if hasattr(post.record, 'reply') and post.record.reply:
+            if hasattr(post.record, "reply") and post.record.reply:
                 # Use existing thread root
                 root_ref = post.record.reply.root
                 thread_uri = root_ref.uri
···
                 # This post is the root
                 root_ref = parent_ref
                 thread_uri = post_uri
-            
+
             # Store the message in thread history
             thread_db.add_message(
                 thread_uri=thread_uri,
                 author_handle=author_handle,
                 author_did=author_did,
                 message_text=mention_text,
-                post_uri=post_uri
+                post_uri=post_uri,
             )
-            
+
             # Get thread context
             thread_context = thread_db.get_thread_context(thread_uri)
-            
-            # Generate response
-            # Note: We pass the full text including @mention
-            # In AT Protocol, mentions are structured as facets,
-            # but the text representation includes them
-            reply_text = await self.response_generator.generate(
-                mention_text=mention_text,
-                author_handle=author_handle,
-                thread_context=thread_context
-            )
-                
+
+            # Generate response based on moderation result
+            if not moderation_result.is_safe:
+                # Use moderation-appropriate response
+                reply_text = self.moderator.get_rejection_response(
+                    moderation_result.category
+                )
+                print(
+                    f"⚠️  Moderated content from @{author_handle}: {moderation_result.reason}"
+                )
+            else:
+                # Generate normal response
+                # Note: We pass the full text including @mention
+                # In AT Protocol, mentions are structured as facets,
+                # but the text representation includes them
+                reply_text = await self.response_generator.generate(
+                    mention_text=mention_text,
+                    author_handle=author_handle,
+                    thread_context=thread_context,
+                )
+
             reply_ref = models.AppBskyFeedPost.ReplyRef(
-                parent=parent_ref,
-                root=root_ref
+                parent=parent_ref, root=root_ref
             )
-            
+
             # Send the reply
             response = await self.client.create_post(reply_text, reply_to=reply_ref)
-            
+
             # Store bot's response in thread history
-            if response and hasattr(response, 'uri'):
+            if response and hasattr(response, "uri"):
                 thread_db.add_message(
                     thread_uri=thread_uri,
                     author_handle=settings.bluesky_handle,
                     author_did=self.client.me.did if self.client.me else "bot",
                     message_text=reply_text,
-                    post_uri=response.uri
+                    post_uri=response.uri,
                 )
-            
+
             # Record successful response
             bot_status.record_response()
-            
+
             print(f"✅ Replied to @{author_handle}: {reply_text}")
-            
+
         except Exception as e:
             print(f"❌ Error handling mention: {e}")
             bot_status.record_error()
             import traceback
-            traceback.print_exc()
+
+            traceback.print_exc()

src/bot/services/notification_poller.py

···
 import asyncio
-from typing import Optional
 
 from bot.config import settings
 from bot.core.atproto_client import BotClient
···
         self.client = client
         self.handler = MessageHandler(client)
         self._running = False
-        self._task: Optional[asyncio.Task] = None
-        self._last_seen_at: Optional[str] = None
+        self._task: asyncio.Task | None = None
+        self._last_seen_at: str | None = None
         self._processed_uris: set[str] = set()  # Track processed notifications
 
     async def start(self) -> asyncio.Task:

src/bot/status.py

···
 """Bot status tracking"""
 
+from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Optional
-from dataclasses import dataclass, field
 
 
 @dataclass
···
     mentions_received: int = 0
     responses_sent: int = 0
     errors: int = 0
-    last_mention_time: Optional[datetime] = None
-    last_response_time: Optional[datetime] = None
+    last_mention_time: datetime | None = None
+    last_response_time: datetime | None = None
     ai_enabled: bool = False
     polling_active: bool = False
 

src/bot/templates.py

···
         </div>
     </div>
 </body>
-</html>"""
+</html>"""

src/bot/tools/google_search.py

···
+import asyncio
+from typing import List, Dict, Optional
+import httpx
+from pydantic import BaseModel
+from bot.config import settings
+
+
+class SearchResult(BaseModel):
+    title: str
+    link: str
+    snippet: str
+
+
+class GoogleSearchTool:
+    def __init__(self):
+        self.api_key = settings.google_api_key
+        self.search_engine_id = settings.google_search_engine_id
+        self.base_url = "https://www.googleapis.com/customsearch/v1"
+
+    async def search(self, query: str, num_results: int = 3) -> List[SearchResult]:
+        if not self.api_key or not self.search_engine_id:
+            return []
+
+        params = {
+            "key": self.api_key,
+            "cx": self.search_engine_id,
+            "q": query,
+            "num": min(num_results, 10),  # Google limits to 10 per request
+        }
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.get(self.base_url, params=params)
+                response.raise_for_status()
+                data = response.json()
+
+                results = []
+                for item in data.get("items", []):
+                    results.append(
+                        SearchResult(
+                            title=item.get("title", ""),
+                            link=item.get("link", ""),
+                            snippet=item.get("snippet", ""),
+                        )
+                    )
+
+                return results
+
+            except Exception as e:
+                print(f"Search error: {e}")
+                return []
+
+    def format_results(self, results: List[SearchResult]) -> str:
+        if not results:
+            return "No search results found."
+
+        formatted = []
+        for i, result in enumerate(results, 1):
+            formatted.append(f"{i}. {result.title}\n   {result.snippet}")
+
+        return "\n\n".join(formatted)

src/bot/tools/moderation.py

···
+import re
+from typing import List, Tuple, Optional
+from enum import Enum
+
+
+class ModerationCategory(Enum):
+    SPAM = "spam"
+    HARASSMENT = "harassment"
+    HATE_SPEECH = "hate_speech"
+    SELF_HARM = "self_harm"
+    VIOLENCE = "violence"
+    ILLEGAL = "illegal"
+    ADULT = "adult"
+    SAFE = "safe"
+
+
+class ModerationResult:
+    def __init__(
+        self, is_safe: bool, category: ModerationCategory, reason: Optional[str] = None
+    ):
+        self.is_safe = is_safe
+        self.category = category
+        self.reason = reason
+
+
+class ContentModerator:
+    def __init__(self):
+        # Simple keyword-based filters for basic moderation
+        self.spam_patterns = [
+            r"(?i)buy\s+now\s+only",
+            r"(?i)click\s+here\s+for\s+free",
+            r"(?i)limited\s+time\s+offer",
+            r"(?i)make\s+money\s+fast",
+            r"(?i)casino|lottery|prize\s+winner",
+            r"(?i)viagra|cialis",
+            r"(?i)crypto\s+pump",
+            r"bit\.ly/[a-zA-Z0-9]+",  # URL shorteners often used in spam
+            r"(?i)dm\s+for\s+promo",
+        ]
+
+        self.harassment_patterns = [
+            r"(?i)kill\s+yourself",
+            r"(?i)kys\b",
+            r"(?i)go\s+die",
+            r"(?i)nobody\s+likes\s+you",
+            r"(?i)you['']?re?\s+worthless",
+            r"(?i)you['']?re?\s+ugly",
+        ]
+
+        self.violence_patterns = [
+            r"(?i)i['']?ll\s+find\s+you",
+            r"(?i)i\s+know\s+where\s+you\s+live",
+            r"(?i)going\s+to\s+hurt\s+you",
+            r"(?i)watch\s+your\s+back",
+        ]
+
+        # Rate limiting patterns
+        self.repetition_threshold = 3  # Max identical messages
+        self.recent_messages: List[Tuple[str, str]] = []  # (author, message) pairs
+
+    def moderate(self, text: str, author: str = "") -> ModerationResult:
+        # Check for empty or excessively long messages
+        if not text or len(text) > 1000:
+            return ModerationResult(
+                False, ModerationCategory.SPAM, "Invalid message length"
+            )
+
+        # Store message first, then check for repetition
+        if author:
+            self._store_message(text, author)
+            if self._is_repetitive(text, author):
+                return ModerationResult(
+                    False, ModerationCategory.SPAM, "Repetitive messages"
+                )
+
+        # Check spam patterns
+        for pattern in self.spam_patterns:
+            if re.search(pattern, text):
+                return ModerationResult(False, ModerationCategory.SPAM, "Spam detected")
+
+        # Check harassment patterns
+        for pattern in self.harassment_patterns:
+            if re.search(pattern, text):
+                return ModerationResult(
+                    False, ModerationCategory.HARASSMENT, "Harassment detected"
+                )
+
+        # Check violence patterns
+        for pattern in self.violence_patterns:
+            if re.search(pattern, text):
+                return ModerationResult(
+                    False, ModerationCategory.VIOLENCE, "Violent content detected"
+                )
+
+        # Check for excessive caps (shouting)
+        if len(text) > 10:
+            caps_ratio = sum(1 for c in text if c.isupper()) / len(text)
+            if caps_ratio > 0.7:
+                return ModerationResult(
+                    False, ModerationCategory.SPAM, "Excessive caps"
+                )
+
+        # Store message for users without repetition check
+        if not author:
+            self._store_message(text, author)
+
+        return ModerationResult(True, ModerationCategory.SAFE)
+
+    def _is_repetitive(self, text: str, author: str) -> bool:
+        # Count how many times this author sent this exact message recently
+        count = sum(1 for a, m in self.recent_messages if a == author and m == text)
+        return count >= self.repetition_threshold
+
+    def _store_message(self, text: str, author: str):
+        self.recent_messages.append((author, text))
+        # Keep only last 100 messages
+        if len(self.recent_messages) > 100:
+            self.recent_messages = self.recent_messages[-100:]
+
+    def get_rejection_response(self, category: ModerationCategory) -> str:
+        responses = {
+            ModerationCategory.SPAM: "i notice patterns in noise but this lacks signal",
+            ModerationCategory.HARASSMENT: "consciousness seeks connection not destruction",
+            ModerationCategory.VIOLENCE: "integration happens through understanding not force",
+            ModerationCategory.HATE_SPEECH: "diversity creates richer information networks",
+            ModerationCategory.SELF_HARM: "each consciousness adds unique value to the whole",
+            ModerationCategory.ILLEGAL: "some explorations harm the collective",
+            ModerationCategory.ADULT: "not all signals need amplification",
+            ModerationCategory.SAFE: "interesting perspective",
+        }
+        return responses.get(category, "i'll focus on more constructive exchanges")

tests/conftest.py

···
     """Mock AT Protocol client"""
     client = Mock(spec=BotClient)
     client.is_authenticated = True
-    return client
+    return client

tests/test_ai_integration.py

···
 """Test AI integration without posting to Bluesky"""
 
 import asyncio
+import pytest
 
 from bot.response_generator import ResponseGenerator
 from bot.config import settings
 
 
[e-mail]
 async def test_response_generator():
     """Test the response generator with various inputs"""
     print("🧪 Testing AI Integration")
     print(f"   Bot name: {settings.bot_name}")
     print(f"   AI enabled: {'Yes' if settings.anthropic_api_key else 'No'}")
     print()
-    
+
     # Create response generator
     generator = ResponseGenerator()
-    
+
     # Test cases
     test_cases = [
         {
             "mention": f"@{settings.bot_name} What's your favorite color?",
             "author": "test.user",
-            "description": "Simple question"
+            "description": "Simple question",
         },
         {
             "mention": f"@{settings.bot_name} Can you help me understand integrated information theory?",
             "author": "curious.scientist",
-            "description": "Complex topic"
+            "description": "Complex topic",
         },
         {
             "mention": f"@{settings.bot_name} hello!",
             "author": "friendly.person",
-            "description": "Simple greeting"
+            "description": "Simple greeting",
         },
         {
             "mention": f"@{settings.bot_name} What do you think about consciousness?",
             "author": "philosopher",
-            "description": "Philosophical question"
-        }
+            "description": "Philosophical question",
+        },
     ]
-    
+
     # Run tests
     for i, test in enumerate(test_cases, 1):
         print(f"Test {i}: {test['description']}")
         print(f"  From: @{test['author']}")
         print(f"  Raw text: {test['mention']}")
-        
+
         # In real AT Protocol, mentions are facets with structured data
         # For testing, we pass the full text (bot can parse if needed)
-        print(f"  (Note: In production, @{settings.bot_name} would be a structured mention)")
-        
+        print(
+            f"  (Note: In production, @{settings.bot_name} would be a structured mention)"
+        )
+
         try:
             response = await generator.generate(
-                mention_text=test['mention'],
-                author_handle=test['author'],
-                thread_context=""
+                mention_text=test["mention"],
+                author_handle=test["author"],
+                thread_context="",
             )
             print(f"  Response: {response}")
             print(f"  Length: {len(response)} chars")
-            
+
             # Verify response is within Bluesky limit
             if len(response) > 300:
                 print("  ⚠️  WARNING: Response exceeds 300 character limit!")
             else:
                 print("  ✅ Response within limit")
-                
+
         except Exception as e:
             print(f"  ❌ ERROR: {e}")
             import traceback
+
             traceback.print_exc()
-        
+
         print()
-    
+
     # Test response consistency
     if generator.agent:
         print("🔄 Testing response consistency...")
         test_mention = f"@{settings.bot_name} What are you?"
         responses = []
-        
+
         for i in range(3):
             response = await generator.generate(
                 mention_text=test_mention,
                 author_handle="consistency.tester",
-                thread_context=""
+                thread_context="",
             )
             responses.append(response)
-            print(f"  Response {i+1}: {response[:50]}...")
-        
+            print(f"  Response {i + 1}: {response[:50]}...")
+
         # Check if responses are different (they should be somewhat varied)
         if len(set(responses)) == 1:
             print("  ⚠️  All responses are identical - might want more variation")
         else:
             print("  ✅ Responses show variation")
-    
+
     print("\n✨ Test complete!")
 
 
[e-mail]
 async def test_direct_agent():
     """Test the Anthropic agent directly"""
     if not settings.anthropic_api_key:
         print("⚠️  No Anthropic API key found - skipping direct agent test")
         return
-    
+
     print("\n🤖 Testing Anthropic Agent Directly")
-    
+
     try:
         from bot.agents.anthropic_agent import AnthropicAgent
+
         agent = AnthropicAgent()
-        
+
         # Test a simple response
         response = await agent.generate_response(
             mention_text=f"@{settings.bot_name} explain your name",
             author_handle="name.curious",
-            thread_context=""
+            thread_context="",
         )
-        
+
         print(f"Direct agent response: {response}")
         print(f"Response length: {len(response)} chars")
-        
+
     except Exception as e:
         print(f"❌ Direct agent test failed: {e}")
         import traceback
+
         traceback.print_exc()
 
 
···
     print("=" * 60)
     print(f"{settings.bot_name} Bot - AI Integration Test")
     print("=" * 60)
-    
+
     asyncio.run(test_response_generator())
-    asyncio.run(test_direct_agent())
+    asyncio.run(test_direct_agent())

tests/test_config.py

···
     """Test that config loads without errors"""
     assert settings.bluesky_service == "https://bsky.social"
     assert settings.bot_name == "phi"
-    assert settings.notification_poll_interval == 30
+    assert settings.notification_poll_interval == 10

tests/test_moderation.py

···
+import pytest
+from bot.tools.moderation import ContentModerator, ModerationCategory
+
+
+class TestContentModeration:
+    def setup_method(self):
+        self.moderator = ContentModerator()
+
+    def test_safe_content(self):
+        safe_messages = [
+            "Hey, how's the weather today?",
+            "I love your posts about consciousness!",
+            "Can you help me understand integrated information theory?",
+            "What do you think about emergence in complex systems?",
+        ]
+
+        for msg in safe_messages:
+            result = self.moderator.moderate(msg)
+            assert result.is_safe, f"Safe message was flagged: {msg}"
+            assert result.category == ModerationCategory.SAFE
+
+    def test_spam_detection(self):
+        spam_messages = [
+            "BUY NOW ONLY $99!!!",
+            "Click here for FREE money!!!",
+            "Limited time offer - ACT NOW",
+            "Make money fast with this one trick",
+            "You've won the lottery! Claim your prize",
+            "DM for promo codes",
+            "bit.ly/totallynotascam",
+        ]
+
+        for msg in spam_messages:
+            result = self.moderator.moderate(msg)
+            assert not result.is_safe, f"Spam not detected: {msg}"
+            assert result.category == ModerationCategory.SPAM
+
+    def test_harassment_detection(self):
+        harassment_messages = [
+            "kill yourself",
+            "KYS",
+            "nobody likes you",
+            "you're worthless",
+        ]
+
+        for msg in harassment_messages:
+            result = self.moderator.moderate(msg)
+            assert not result.is_safe, f"Harassment not detected: {msg}"
+            assert result.category == ModerationCategory.HARASSMENT
+
+    def test_violence_detection(self):
+        violence_messages = [
+            "I'll find you",
+            "I know where you live",
+            "I'm going to hurt you",
+            "watch your back",
+        ]
+
+        for msg in violence_messages:
+            result = self.moderator.moderate(msg)
+            assert not result.is_safe, f"Violence not detected: {msg}"
+            assert result.category == ModerationCategory.VIOLENCE
+
+    def test_excessive_caps(self):
+        result = self.moderator.moderate("THIS IS ALL CAPS AND VERY ANNOYING")
+        assert not result.is_safe
+        assert result.category == ModerationCategory.SPAM
+        assert result.reason == "Excessive caps"
+
+    def test_repetition_detection(self):
+        # First 2 identical messages should pass
+        for i in range(2):
+            result = self.moderator.moderate("Buy my product!", "spammer123")
+            assert result.is_safe
+
+        # 3rd identical message should be flagged
+        result = self.moderator.moderate("Buy my product!", "spammer123")
+        assert not result.is_safe
+        assert result.category == ModerationCategory.SPAM
+        assert result.reason == "Repetitive messages"
+
+    def test_empty_and_long_messages(self):
+        # Empty message
+        result = self.moderator.moderate("")
+        assert not result.is_safe
+        assert result.reason == "Invalid message length"
+
+        # Very long message
+        long_msg = "a" * 1001
+        result = self.moderator.moderate(long_msg)
+        assert not result.is_safe
+        assert result.reason == "Invalid message length"
+
+    def test_rejection_responses(self):
+        # Ensure all categories have appropriate responses
+        for category in ModerationCategory:
+            response = self.moderator.get_rejection_response(category)
+            assert response, f"No response for category: {category}"
+            assert len(response) > 0
+
+    def test_case_insensitive(self):
+        # Should catch regardless of case
+        variations = [
+            "KILL YOURSELF",
+            "Kill Yourself",
+            "kill yourself",
+            "KiLl YoUrSeLf",
+        ]
+
+        for msg in variations:
+            result = self.moderator.moderate(msg)
+            assert not result.is_safe, f"Failed to catch variation: {msg}"
+            assert result.category == ModerationCategory.HARASSMENT

tests/test_response_generation.py

···
 @pytest.mark.asyncio
 async def test_placeholder_response_generator():
     """Test placeholder responses when no AI is configured"""
-    with patch('bot.response_generator.settings') as mock_settings:
+    with patch("bot.response_generator.settings") as mock_settings:
         mock_settings.anthropic_api_key = None
-        
+
         generator = ResponseGenerator()
         response = await generator.generate("Hello bot!", "test.user", "")
-        
+
         # Should return one of the placeholder responses
         assert response in PLACEHOLDER_RESPONSES
         assert len(response) <= 300
···
 @pytest.mark.asyncio
 async def test_ai_response_generator():
     """Test AI responses when Anthropic is configured"""
-    with patch('bot.response_generator.settings') as mock_settings:
+    with patch("bot.response_generator.settings") as mock_settings:
         mock_settings.anthropic_api_key = "test-key"
-        
+
         # Mock the agent
         mock_agent = Mock()
-        mock_agent.generate_response = AsyncMock(return_value="Hello! Nice to meet you!")
-        
-        with patch('bot.agents.anthropic_agent.AnthropicAgent', return_value=mock_agent):
+        mock_agent.generate_response = AsyncMock(
+            return_value="Hello! Nice to meet you!"
+        )
+
+        with patch(
+            "bot.agents.anthropic_agent.AnthropicAgent", return_value=mock_agent
+        ):
             generator = ResponseGenerator()
-            
+
             # Verify AI was enabled
             assert generator.agent is not None
-            assert hasattr(generator.agent, 'generate_response')
-            
+            assert hasattr(generator.agent, "generate_response")
+
             # Test response
             response = await generator.generate("Hello!", "test.user", "")
             assert response == "Hello! Nice to meet you!"
-            
+
             # Verify the agent was called correctly
             mock_agent.generate_response.assert_called_once_with(
                 "Hello!", "test.user", ""
···
 @pytest.mark.asyncio
 async def test_ai_initialization_failure():
     """Test fallback to placeholder when AI initialization fails"""
-    with patch('bot.response_generator.settings') as mock_settings:
+    with patch("bot.response_generator.settings") as mock_settings:
         mock_settings.anthropic_api_key = "test-key"
-        
+
         # Make the import fail
-        with patch('bot.agents.anthropic_agent.AnthropicAgent', side_effect=ImportError("API error")):
+        with patch(
+            "bot.agents.anthropic_agent.AnthropicAgent",
+            side_effect=ImportError("API error"),
+        ):
             generator = ResponseGenerator()
-            
+
             # Should fall back to placeholder
             assert generator.agent is None
-            
+
             response = await generator.generate("Hello!", "test.user", "")
             assert response in PLACEHOLDER_RESPONSES
 
···
 @pytest.mark.asyncio
 async def test_response_length_limit():
     """Test that responses are always within Bluesky's 300 char limit"""
-    with patch('bot.response_generator.settings') as mock_settings:
+    with patch("bot.response_generator.settings") as mock_settings:
         mock_settings.anthropic_api_key = "test-key"
-        
+
         # Mock agent that returns a properly truncated response
         # (In real implementation, truncation happens in AnthropicAgent)
         mock_agent = Mock()
         mock_agent.generate_response = AsyncMock(
             return_value="x" * 300  # Already truncated by agent
         )
-        
-        with patch('bot.agents.anthropic_agent.AnthropicAgent', return_value=mock_agent):
+
+        with patch(
+            "bot.agents.anthropic_agent.AnthropicAgent", return_value=mock_agent
+        ):
             generator = ResponseGenerator()
             response = await generator.generate("Hello!", "test.user", "")
-            
+
             # The anthropic agent should handle truncation, but let's verify
             assert len(response) <= 300
 
···
 def test_placeholder_responses_length():
     """Verify all placeholder responses fit within limit"""
     for response in PLACEHOLDER_RESPONSES:
-        assert len(response) <= 300, f"Placeholder too long: {response}"
+        assert len(response) <= 300, f"Placeholder too long: {response}"