Sanctum: Broca 2 v0.10.0 introduces revolutionary plugin auto-discovery and dynamic loading capabilities. Learn how this major update transforms Broca from a hardcoded plugin system to a truly extensible, self-contained plugin architecture.

We're excited to announce Sanctum: Broca 2 v0.10.0, a transformative release that fundamentally changes how plugins work in Broca. This release addresses one of the most critical architectural limitations: the hardcoded plugin loading system that prevented easy extensibility. No more manual plugin registration—plugins are now automatically discovered, loaded, and configured at runtime.

Repository: github.com/actuallyrizzn/broca-2

Highlights of This Release

🔍 Plugin Auto-Discovery System

Dynamic plugin discovery: Plugins are automatically discovered and loaded from the plugins/ directory without any manual registration or hardcoded imports.

Self-contained architecture: All plugins are now truly self-contained with lazy imports, ensuring external dependencies are only loaded when needed.

Dynamic settings injection: Plugin settings are automatically injected via the new apply_settings() method, enabling runtime configuration without restarts.

🌐 Web Chat Plugin Integration

Complete polling-based web chat: Full integration with external PHP APIs for secure web chat functionality.

Pull-based architecture: Broca2 plugins now poll external APIs for messages, eliminating the need for new public ports on the Sanctum server.

Session management: Unique user identification with 16-character hex UIDs for persistent identity across web sessions.

🔧 Enhanced Plugin Interface

Standardized response handlers: New (response, profile, message_id) signature for consistent message routing across all platforms.

Platform-agnostic formatting: Updated MessageFormatter to use dynamic platform-specific ID labels instead of hardcoded "Telegram ID".

Database integration patterns: Standardized user and profile creation patterns for consistent data management.

Why This Matters

This release solves fundamental architectural limitations that were preventing true plugin extensibility. Previously, adding new plugins required modifying core code and restarting the system. Now, plugins are automatically discovered and loaded with:

• Zero-configuration deployment: Drop a plugin folder into plugins/ and it's automatically loaded
• Self-contained dependencies: Plugins only load their dependencies when actually used
• Dynamic configuration: Plugin settings can be updated without system restarts
• Platform-agnostic design: Message formatting adapts to any platform automatically

Technical Changes

Added

• Plugin Auto-Discovery: Dynamic scanning and loading of plugins from plugins/ directory
• Web Chat Plugin: Complete polling-based integration with external PHP APIs
• Enhanced Plugin Interface: New apply_settings() method for dynamic configuration
• Platform-Agnostic Message Formatting: Dynamic platform ID labels in message formatting
• Database Integration Patterns: Standardized user and profile creation workflows

Changed

• Plugin Architecture: Transitioned from hardcoded loading to dynamic auto-discovery
• Message Handler Requirements: Standardized response handler pattern with consistent signatures
• Settings Management: Implemented lazy initialization and fallback patterns
• Import Patterns: Established lazy import patterns for self-contained plugins

Fixed

• Plugin Loading Errors: Resolved module import and dependency issues
• Message Routing: Fixed response handler callable requirements
• User Details Lookup: Corrected database integration for user and profile creation
• Settings Validation: Improved error handling for missing or invalid settings
• Platform-Specific Labels: Fixed hardcoded "Telegram ID" labels to use platform-specific naming

What's Next

This release sets the foundation for truly extensible plugin development:

• Advanced Plugin APIs: Enhanced interfaces for complex plugin functionality
• Plugin Monitoring: Health monitoring and performance metrics for plugins
• Plugin Versioning: Automatic plugin updates and dependency management

Getting Started

For new plugin development:

from plugins import Plugin

class MyPlugin(Plugin):
    def get_name(self) -> str:
        return "my_plugin"
    
    def get_platform(self) -> str:
        return "my_platform"
    
    def get_message_handler(self):
        return self._handle_response
    
    async def _handle_response(self, response: str, profile, message_id: int) -> None:
        # Handle sending response to platform
        pass

from plugins import Plugin

class MyPlugin(Plugin): def get_name(self) -> str: return "my_plugin"

def get_platform(self) -> str: return "my_platform"

def get_message_handler(self): return self._handle_response

async def _handle_response(self, response: str, profile, message_id: int) -> None:

Handle sending response to platform

pass

For existing installations, simply restart Broca2 to enable auto-discovery of existing plugins.

Key Learnings from Development

The development of this release revealed critical patterns for scalable plugin architecture:

• Lazy Loading: External dependencies should only be imported when needed
• Self-Containment: Plugins must be completely independent of core infrastructure
• Dynamic Configuration: Settings should be injectable at runtime
• Standardized Interfaces: Consistent patterns across all plugins enable easy maintenance

We invite the community to develop new plugins and explore the enhanced extensibility capabilities. The plugin development guide has been completely updated with real-world examples and troubleshooting guidance.

This release represents a major step toward Broca2 becoming a truly extensible platform for agent communication and integration.