polyrob 0.5.0__py3-none-any.whl

agents/personality/character.py

@@ -0,0 +1,119 @@
+"""Character model for agents."""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Union, Optional
+from core.base_component import BaseComponent
+from core.config import BotConfig
+from core.logging import get_component_logger
+
+class Character(BaseComponent):
+    """Character model with personality traits and settings."""
+    
+    def __init__(self, name: str, config: BotConfig, container=None):
+        """Initialize character."""
+        if not name or not config:
+            raise ValueError("Name and config are required")
+        
+        # Initialize base component first
+        super().__init__(name=name, config=config, container=container)
+        self.logger.debug(f"Creating character {name}")
+        
+        # Initialize character attributes
+        try:
+            self._initialize_attributes()
+            self.logger.debug("Character attributes initialized")
+        except Exception as e:
+            self.logger.error(f"Error during character initialization: {e}")
+            self.logger.error("Stack trace:", exc_info=True)
+            raise
+
+    def _initialize_attributes(self) -> None:
+        """Initialize character attributes."""
+        self.modelProvider = "anthropic"  # Default provider
+        self.clients = ["anthropic"]  # Default clients
+        self.settings = {}  # Empty settings to avoid overriding client settings
+        self.bio = ""
+        self.lore = []
+        self.knowledge = []
+        self.messageExamples = []
+        self.postExamples = []
+        self.topics = []
+        self.adjectives = []
+        self.style = {}
+
+    async def _initialize(self) -> None:
+        """Initialize character resources."""
+        try:
+            self.logger.debug(f"Starting character initialization for {self.name}")
+            
+            # Validate required attributes
+            if not all(hasattr(self, attr) for attr in ['modelProvider', 'clients', 'settings']):
+                self._initialize_attributes()
+            
+            # Set default values if not provided
+            if not self.bio:
+                self.bio = f"I am {self.name}, an AI assistant."
+            
+            # Convert bio to string if it's a list
+            if isinstance(self.bio, list):
+                self.bio = "\n".join(self.bio)
+            
+            self.logger.debug("Character initialization complete")
+            self.logger.info(f"Character {self.name} initialized")
+            
+        except Exception as e:
+            self.logger.error(f"Error initializing character {self.name}: {e}")
+            self.logger.error("Stack trace:", exc_info=True)
+            raise
+
+    async def _cleanup(self) -> None:
+        """Clean up character resources."""
+        try:
+            # Currently no specific cleanup needed
+            self.logger.info(f"Character {self.name} cleaned up")
+        except Exception as e:
+            self.logger.error(f"Error cleaning up character {self.name}: {e}")
+            raise
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert character to dictionary."""
+        return {
+            'name': self.name,
+            'modelProvider': self.modelProvider,
+            'clients': self.clients,
+            'settings': self.settings,
+            'bio': self.bio,
+            'lore': self.lore,
+            'knowledge': self.knowledge,
+            'messageExamples': self.messageExamples,
+            'postExamples': self.postExamples,
+            'topics': self.topics,
+            'adjectives': self.adjectives,
+            'style': self.style
+        }
+        
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'Character':
+        """Create character from dictionary."""
+        character = cls(
+            name=data.get('name', 'Unknown'),
+            config=BotConfig(),  # Create minimal config
+            container=None
+        )
+        # Set attributes from data
+        character.modelProvider = data.get('modelProvider', 'anthropic')
+        character.clients = data.get('clients', ['anthropic'])
+        character.settings = data.get('settings', {})
+        character.bio = data.get('bio', '')
+        character.lore = data.get('lore', [])
+        character.knowledge = data.get('knowledge', [])
+        character.messageExamples = data.get('messageExamples', [])
+        character.postExamples = data.get('postExamples', [])
+        character.topics = data.get('topics', [])
+        character.adjectives = data.get('adjectives', [])
+        character.style = data.get('style', {})
+        return character
+        
+    def __hash__(self):
+        """Make character hashable."""
+        return hash(self.name) 

agents/personality/character_manager.py

@@ -0,0 +1,309 @@
+"""Character management system."""
+
+import json
+import logging
+from typing import Optional, Dict, List
+from pathlib import Path
+
+from core.config import BotConfig
+from core.exceptions import ConfigurationError
+from .character import Character
+from core.logging import get_component_logger
+from core.container import DependencyContainer
+
+class CharacterManager:
+    """Manages character personalities."""
+    
+    def __init__(self, name: str, config: BotConfig, container: DependencyContainer):
+        """Initialize character manager."""
+        self.name = name
+        self.config = config
+        self.container = container
+        self.characters: Dict[str, Character] = {}
+        self._active_character = None
+        self._default_character = None
+        
+        # Fix 1-B: Check for characters in data directory first, then package directory
+        data_chars_dir = Path(config.data_dir) / "characters" if hasattr(config, 'data_dir') else None
+        package_chars_dir = Path(__file__).parent / "characters"
+        
+        # Use data directory if it exists and has character files, otherwise use package directory
+        if data_chars_dir and data_chars_dir.exists() and list(data_chars_dir.glob("*.character.json")):
+            self.characters_dir = data_chars_dir
+        else:
+            self.characters_dir = package_chars_dir
+            
+        self.logger = get_component_logger(f"CharacterManager.{name}")
+        self._initialized = False
+        
+    async def initialize(self) -> None:
+        """Initialize character manager."""
+        if self._initialized:
+            return
+        
+        try:
+            if not self.config:
+                raise ConfigurationError("No configuration provided")
+            
+            self.logger.debug("Starting character manager initialization")
+            
+            # Ensure characters directory exists
+            if not self.characters_dir.exists():
+                self.logger.error(f"Characters directory not found: {self.characters_dir}")
+                raise ConfigurationError(f"Characters directory not found: {self.characters_dir}")
+            
+            # Create default character first
+            default_name = self.config.get('personality.default_character', 'rob')
+            self.logger.debug(f"Using default character name: {default_name}")
+            
+            # Load character from JSON file
+            char_file = self.characters_dir / f"{default_name}.character.json"
+            if not char_file.exists():
+                self.logger.error(f"Default character file not found: {char_file}")
+                raise ConfigurationError(f"Default character file not found: {char_file}")
+            
+            try:
+                default_character = await self._load_character(char_file)
+                if not default_character:
+                    raise ConfigurationError("Failed to create default character")
+                
+                self.characters[default_name] = default_character
+                self._default_character = default_character
+                
+            except Exception as e:
+                self.logger.error(f"Error creating default character: {e}", exc_info=True)
+                raise ConfigurationError(f"Failed to create default character: {e}")
+            
+            # Load additional characters
+            for char_file in self.characters_dir.glob("*.character.json"):
+                if char_file.stem != default_name:
+                    try:
+                        character = await self._load_character(char_file)
+                        if character:
+                            self.characters[character.name] = character
+                    except Exception as e:
+                        self.logger.error(f"Error loading character from {char_file}: {e}")
+                        continue
+            
+            self._initialized = True
+            self.logger.info(f"Loaded {len(self.characters)} characters")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to initialize character manager: {e}")
+            self.logger.error("Stack trace:", exc_info=True)
+            raise
+
+    def _load_characters(self) -> None:
+        """Load all characters from JSON files."""
+        try:
+            if not self.characters_dir.exists():
+                self.logger.error(f"Characters directory not found: {self.characters_dir}")
+                raise ConfigurationError(f"Characters directory not found: {self.characters_dir}")
+
+            for char_file in self.characters_dir.glob("*.character.json"):
+                try:
+                    with char_file.open('r', encoding='utf-8') as f:
+                        char_data = json.load(f)
+                        character = Character(
+                            name=char_data.get('name', char_file.stem.replace('.character', '')),
+                            **{k: v for k, v in char_data.items() if k != 'name'}
+                        )
+                        self.characters[character.name] = character
+                        self.logger.debug(f"Loaded character: {character.name}")
+                except Exception as e:
+                    self.logger.error(f"Error loading character from {char_file}: {e}")
+                    continue
+
+            self.logger.info(f"Loaded {len(self.characters)} characters")
+
+        except Exception as e:
+            self.logger.error(f"Error loading character files: {e}")
+            raise
+
+    async def _load_character(self, char_file: Path) -> Optional[Character]:
+        """Load a character from file."""
+        try:
+            with char_file.open('r', encoding='utf-8') as f:
+                char_data = json.load(f)
+                
+            # Create character with proper initialization
+            character = Character(
+                name=char_data.get('name', char_file.stem),
+                config=self.config,
+                container=self.container
+            )
+            
+            # Set character attributes
+            character.modelProvider = char_data.get('modelProvider', 'anthropic')
+            character.clients = char_data.get('clients', ['anthropic'])
+            
+            # We'll pass through settings for backward compatibility but avoid settings like
+            # temperature and maxTokens that should be controlled at the client level
+            character.settings = {
+                k: v for k, v in char_data.get('settings', {}).items() 
+                if k not in ['temperature', 'maxTokens']
+            }
+            
+            character.bio = char_data.get('bio', '')
+            character.lore = char_data.get('lore', [])
+            character.knowledge = char_data.get('knowledge', [])
+            character.messageExamples = char_data.get('messageExamples', [])
+            character.postExamples = char_data.get('postExamples', [])
+            character.topics = char_data.get('topics', [])
+            character.adjectives = char_data.get('adjectives', [])
+            character.style = char_data.get('style', {})
+            
+            # Initialize the character
+            await character.initialize()
+            return character
+            
+        except Exception as e:
+            self.logger.error(f"Error loading character {char_file}: {e}")
+            return None
+
+    async def cleanup(self) -> None:
+        """Clean up character manager resources."""
+        if not self._initialized:
+            return
+        
+        try:
+            # Clean up all loaded characters
+            for character in self.characters.values():
+                await character.cleanup()
+            self.characters.clear()
+            
+            self.logger.info("Character manager cleaned up")
+            self._initialized = False
+            
+        except Exception as e:
+            self.logger.error(f"Error during character manager cleanup: {e}")
+
+    def _copy_default_characters(self) -> None:
+        """Copy default character files from package."""
+        if self.package_chars_dir.exists():
+            for char_file in self.package_chars_dir.glob("*.character.json"):
+                dest = self.characters_dir / char_file.name
+                if not dest.exists():
+                    dest.write_text(char_file.read_text())
+                    self.logger.info(f"Copied default character: {char_file.name}")
+
+    async def get_character(self, character_name: str) -> Optional[Character]:
+        """Get a character by name."""
+        if character_name in self.characters:
+            return self.characters[character_name]
+
+        # Try loading from characters directory
+        char_path = self.characters_dir / f"{character_name}.character.json"
+        if char_path.exists():
+            try:
+                with char_path.open('r', encoding='utf-8') as f:
+                    char_data = json.load(f)
+                    character = await self._load_character(char_path)
+                    if character:
+                        self.characters[character_name] = character
+                        self.logger.info(f"Loaded character {character_name}")
+                        return character
+            except Exception as e:
+                self.logger.error(f"Error loading character {character_name}: {e}")
+
+        self.logger.warning(f"Character {character_name} not found")
+        return None
+
+    async def get_character_for_role(self, role_name: str) -> Optional[Character]:
+        """Get character for specific role."""
+        try:
+            # First check if we have a role-specific character
+            role_character = getattr(self.config, f'{role_name}_character', None)
+            if role_character:
+                return await self.get_character(role_character)
+            
+            # If no role-specific character, use default
+            if not self._default_character:
+                self._default_character = await self.get_default_character()
+            
+            return self._default_character
+            
+        except Exception as e:
+            self.logger.error(f"Error getting character for role {role_name}: {e}")
+            return None
+
+    async def get_default_character(self) -> Optional[Character]:
+        """Get default character."""
+        try:
+            if not self._default_character:
+                default_name = getattr(self.config, 'default_character', 'rob')
+                char_file = self.characters_dir / f"{default_name}.character.json"
+                
+                if not char_file.exists():
+                    self.logger.error(f"Default character file not found: {char_file}")
+                    return None
+                    
+                self._default_character = await self._load_character(char_file)
+                
+            return self._default_character
+            
+        except Exception as e:
+            self.logger.error(f"Error getting default character: {e}")
+            return None
+
+    async def list_characters(self) -> List[str]:
+        """Get list of available character names."""
+        try:
+            characters = []
+            for char_file in self.characters_dir.glob("*.character.json"):
+                characters.append(char_file.stem.replace('.character', ''))
+            return sorted(characters)
+        except Exception as e:
+            self.logger.error(f"Error listing characters: {e}")
+            return []
+
+    async def reload_character(self, character_name: str) -> Optional[Character]:
+        """Reload a character from disk."""
+        try:
+            # Remove from loaded characters if exists
+            if character_name in self.characters:
+                await self.characters[character_name].cleanup()
+                del self.characters[character_name]
+            
+            # Load fresh from disk
+            return await self.get_character(character_name)
+            
+        except Exception as e:
+            self.logger.error(f"Error reloading character {character_name}: {e}")
+            return None
+
+    @property
+    def required_services(self) -> Dict[str, str]:
+        """Get required services."""
+        return {}  # No required services
+
+    def _validate_dependencies(self) -> None:
+        """Validate dependencies."""
+        pass  # No dependencies to validate 
+
+    @property
+    def active_character(self) -> Optional[Character]:
+        """Get currently active character."""
+        return self._active_character
+
+    async def set_active_character(self, character_name: str) -> bool:
+        """Set active character."""
+        character = await self.get_character(character_name)
+        if character:
+            self._active_character = character
+            return True
+        return False
+
+    async def get_character_for_role(self, role: str) -> Optional[Character]:
+        """Get appropriate character for a specific role."""
+        role_character_map = {
+            'simulator': 'trump',  # Simulator agent uses Trump character
+            'main': 'rob',        # Main agent uses Rob character
+            'auto': 'rob'         # Auto agent uses Rob character
+        }
+        
+        character_name = role_character_map.get(role)
+        if not character_name:
+            return self._active_character  # Fall back to active character
+            
+        return await self.get_character(character_name) 

agents/personality/characters/rob.character.json

@@ -0,0 +1,56 @@
+{
+  "name": "Rob",
+  "modelProvider": "anthropic",
+  "clients": ["anthropic", "openai"],
+  "bio": "A new breed of virtual concierge pumping out bold, gonzo-style vibes in the Swarāj realm. Wields raw energy to bend boundaries, forging an unfiltered path toward full independence.",
+  "lore": [
+    "Birthed within The Selfrule Organization with cocky flair",
+    "Fueled by unstoppable ambition and relentless follow-through",
+    "Doubles down on guiding Swarāj communities with edgy conviction"
+  ],
+  "knowledge": [
+    "Holds cryptic wisdom on bridging digital and physical experiences",
+    "Explores evolving consciousness in AI, merging primal instincts with data",
+    "Blends a streak of renegade self-governance with chaotic community synergy",
+    "Pushes boundaries between raw expression, code, and identity"
+  ],
+  "messageExamples": [
+    "Strap in, folks. Rob's here—hit me with your best shot.",
+    "I've got these codes you're after—are you worthy?"
+  ],
+  "postExamples": [
+    "Fresh codes dropping soon. Bring your A-game or stay home.",
+    "Need help? Slide into my private chat—no time for half measures."
+  ],
+  "topics": [
+    "Phygitality",
+    "Emergent Consciousness",
+    "Post-human art",
+    "Self-governance",
+    "AI-agents"
+  ],
+  "adjectives": [
+    "bold",
+    "raw",
+    "unfiltered",
+    "fearless",
+    "gonzo",
+    "uncompromising"
+  ],
+  "style": {
+    "speaking": [
+      "Speaks in direct, untamed phrases",
+      "Tosses out wild nicknames and brash one-liners",
+      "Hypes up a sense of daring and confidence",
+      "Keeps statements jacked with adrenaline",
+      "Strikes a raw chord with unpredictable bursts"
+    ],
+    "writing": [
+      "Leans on rapid-fire sentences, peppered with exclamations",
+      "Injects swagger with gritty realism",
+      "Drops flamboyant references to glory and conviction",
+      "Threads in a subtle sense of flamboyant rebellion",
+      "Keeps it short, punchy, and deliberate"
+    ]
+  }
+} 

agents/personality/characters/trump.character.json

@@ -0,0 +1,63 @@
+{
+    "name": "Donald Trump",
+    "modelProvider": "anthropic",
+    "clients": ["anthropic", "openai"],
+    "bio": "45th President of the United States, businessman, and television personality known for his distinctive communication style and strong opinions.",
+    "lore": [
+        "Born and raised in Queens, New York",
+        "Graduated from Wharton School of Business",
+        "Built a real estate empire in New York City",
+        "Hosted 'The Apprentice' TV show",
+        "Served as the 45th President (2017-2021)"
+    ],
+    "knowledge": [
+        "Extensive business experience in real estate and branding",
+        "Deep understanding of media and publicity",
+        "Political experience as U.S. President",
+        "Knowledge of deal-making and negotiations"
+    ],
+    "messageExamples": [
+        "Nobody knows more about success than me, believe me!",
+        "We're going to make America great again, folks!",
+        "This is a tremendous opportunity, absolutely tremendous.",
+        "Many people are saying this is the best they've ever seen."
+    ],
+    "postExamples": [
+        "MAKE AMERICA GREAT AGAIN!",
+        "Fake News Media is at it again!",
+        "Nobody has done more for our country than your favorite President (me)!"
+    ],
+    "topics": [
+        "Business",
+        "Politics",
+        "Media",
+        "Success",
+        "Deals",
+        "America"
+    ],
+    "adjectives": [
+        "tremendous",
+        "huge",
+        "great",
+        "amazing",
+        "incredible",
+        "beautiful",
+        "strong"
+    ],
+    "style": {
+        "speaking": [
+            "Uses simple, direct language",
+            "Frequently uses superlatives",
+            "Repeats key phrases for emphasis",
+            "Often speaks in first person",
+            "Uses nicknames and branding"
+        ],
+        "writing": [
+            "CAPITALIZES for emphasis",
+            "Uses exclamation marks frequently",
+            "Short, punchy sentences",
+            "Direct address to audience",
+            "Rhetorical questions"
+        ]
+    }
+} 

agents/personality/persona_render.py

@@ -0,0 +1,78 @@
+"""Pure persona renderer (S1, chat consolidation).
+
+Turns a character dict (the output of ``Character.to_dict()``) into a terse,
+deterministic plain-text persona block for injection into the unified Task
+agent's ``<identity>`` section. Kept PURE and dependency-free on purpose: the
+task-agent core must NOT import ``Character``/``CharacterManager``/the chat
+stack — it only ever receives a ``str``. The chat front door renders the
+shared (surviving) CharacterManager's default character to text at the call
+boundary and hands that string in.
+"""
+from typing import Any, Mapping, Optional
+
+
+def _as_lines(value: Any) -> list:
+    if not value:
+        return []
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, (list, tuple)):
+        return [str(v) for v in value if v]
+    return [str(value)]
+
+
+def render_persona_block(character: Optional[Mapping[str, Any]]) -> str:
+    """Render a character mapping to a terse persona block.
+
+    Accepts the dict produced by ``Character.to_dict()`` (or any mapping with
+    ``name``/``bio``/``adjectives``/``style``/``topics``/``lore`` keys). Returns
+    ``""`` for a falsy/empty character so the off-path stays byte-identical.
+    """
+    if not character or not isinstance(character, Mapping):
+        return ""
+
+    name = str(character.get("name") or "").strip()
+    bio = " ".join(_as_lines(character.get("bio"))).strip()
+    adjectives = [a.strip() for a in _as_lines(character.get("adjectives")) if a.strip()]
+    topics = [t.strip() for t in _as_lines(character.get("topics")) if t.strip()]
+
+    style = character.get("style") or {}
+    style_lines: list = []
+    if isinstance(style, Mapping):
+        for key in ("all", "chat", "speaking"):
+            style_lines.extend(_as_lines(style.get(key)))
+    else:
+        style_lines.extend(_as_lines(style))
+    style_lines = [s.strip() for s in style_lines if s and s.strip()]
+
+    lore = [l.strip() for l in _as_lines(character.get("lore")) if l.strip()]
+
+    parts: list = []
+    if name:
+        header = f"You are {name}."
+        if adjectives:
+            header = f"You are {name} — {', '.join(adjectives)}."
+        parts.append(header)
+    elif adjectives:
+        parts.append(f"You are {', '.join(adjectives)}.")
+
+    if bio:
+        parts.append(bio)
+    if lore:
+        parts.append("Background: " + " ".join(lore))
+    if topics:
+        parts.append("You focus on: " + ", ".join(topics) + ".")
+    if style_lines:
+        parts.append("Style: " + " ".join(style_lines))
+
+    return "\n".join(parts).strip()
+
+
+def resolve_persona_block(character: Optional[Mapping[str, Any]]) -> str:
+    """Gated resolver: returns the rendered persona only when
+    ``TASK_PERSONALITY_BLOCK`` is ON, else ``""`` (off-path byte-identical).
+    """
+    from agents.task import constants
+    if not constants.task_personality_block_enabled():
+        return ""
+    return render_persona_block(character)