astraagent 2.25.6

package/astra/core/state.py

@@ -0,0 +1,366 @@
+"""
+Agent State Management for AstraAgent.
+Tracks the current state, history, and context of the agent.
+"""
+
+import uuid
+import json
+from datetime import datetime
+from dataclasses import dataclass, field, asdict
+from typing import Optional, Dict, Any, List
+from enum import Enum
+from pathlib import Path
+
+
+class TaskStatus(Enum):
+    """Status of a task."""
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    BLOCKED = "blocked"
+    CANCELLED = "cancelled"
+
+
+class ActionStatus(Enum):
+    """Status of an action."""
+    PENDING = "pending"
+    EXECUTING = "executing"
+    SUCCESS = "success"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+    REQUIRES_APPROVAL = "requires_approval"
+
+
+@dataclass
+class Action:
+    """Represents a single action taken by the agent."""
+    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    tool: str = ""
+    args: Dict[str, Any] = field(default_factory=dict)
+    thought: str = ""
+    result: Optional[Any] = None
+    error: Optional[str] = None
+    status: ActionStatus = ActionStatus.PENDING
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    execution_time_ms: Optional[float] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        data = asdict(self)
+        data['status'] = self.status.value
+        data['started_at'] = self.started_at.isoformat() if self.started_at else None
+        data['completed_at'] = self.completed_at.isoformat() if self.completed_at else None
+        return data
+    
+    def mark_executing(self):
+        self.status = ActionStatus.EXECUTING
+        self.started_at = datetime.now()
+    
+    def mark_success(self, result: Any):
+        self.status = ActionStatus.SUCCESS
+        self.result = result
+        self.completed_at = datetime.now()
+        if self.started_at:
+            self.execution_time_ms = (self.completed_at - self.started_at).total_seconds() * 1000
+    
+    def mark_failed(self, error: str):
+        self.status = ActionStatus.FAILED
+        self.error = error
+        self.completed_at = datetime.now()
+        if self.started_at:
+            self.execution_time_ms = (self.completed_at - self.started_at).total_seconds() * 1000
+
+
+@dataclass
+class Task:
+    """Represents a task or sub-task in the plan."""
+    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    description: str = ""
+    parent_id: Optional[str] = None
+    subtasks: List['Task'] = field(default_factory=list)
+    actions: List[Action] = field(default_factory=list)
+    status: TaskStatus = TaskStatus.PENDING
+    priority: int = 5  # 1-10, 1 being highest
+    created_at: datetime = field(default_factory=datetime.now)
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    result: Optional[str] = None
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'id': self.id,
+            'description': self.description,
+            'parent_id': self.parent_id,
+            'subtasks': [st.to_dict() for st in self.subtasks],
+            'actions': [a.to_dict() for a in self.actions],
+            'status': self.status.value,
+            'priority': self.priority,
+            'created_at': self.created_at.isoformat(),
+            'started_at': self.started_at.isoformat() if self.started_at else None,
+            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+            'result': self.result,
+            'error': self.error,
+            'metadata': self.metadata
+        }
+    
+    def add_subtask(self, description: str, priority: int = 5) -> 'Task':
+        subtask = Task(
+            description=description,
+            parent_id=self.id,
+            priority=priority
+        )
+        self.subtasks.append(subtask)
+        return subtask
+    
+    def add_action(self, action: Action):
+        self.actions.append(action)
+    
+    @property
+    def is_complete(self) -> bool:
+        return self.status in [TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.CANCELLED]
+    
+    @property
+    def all_subtasks_complete(self) -> bool:
+        return all(st.is_complete for st in self.subtasks)
+
+
+@dataclass
+class Plan:
+    """Represents the agent's plan for achieving a goal."""
+    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    goal: str = ""
+    tasks: List[Task] = field(default_factory=list)
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+    version: int = 1
+    notes: str = ""
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'id': self.id,
+            'goal': self.goal,
+            'tasks': [t.to_dict() for t in self.tasks],
+            'created_at': self.created_at.isoformat(),
+            'updated_at': self.updated_at.isoformat(),
+            'version': self.version,
+            'notes': self.notes
+        }
+    
+    def add_task(self, description: str, priority: int = 5) -> Task:
+        task = Task(description=description, priority=priority)
+        self.tasks.append(task)
+        self.updated_at = datetime.now()
+        return task
+    
+    def get_next_task(self) -> Optional[Task]:
+        """Get the next pending task with highest priority."""
+        pending = [t for t in self.tasks if t.status == TaskStatus.PENDING]
+        if not pending:
+            return None
+        return min(pending, key=lambda t: t.priority)
+    
+    @property
+    def progress(self) -> float:
+        """Calculate completion percentage."""
+        if not self.tasks:
+            return 0.0
+        completed = sum(1 for t in self.tasks if t.status == TaskStatus.COMPLETED)
+        return (completed / len(self.tasks)) * 100
+    
+    @property
+    def is_complete(self) -> bool:
+        return all(t.is_complete for t in self.tasks)
+
+
+@dataclass
+class Observation:
+    """Represents an observation or insight from the agent."""
+    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    content: str = ""
+    source: str = ""
+    timestamp: datetime = field(default_factory=datetime.now)
+    importance: int = 5  # 1-10
+    tags: List[str] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'id': self.id,
+            'content': self.content,
+            'source': self.source,
+            'timestamp': self.timestamp.isoformat(),
+            'importance': self.importance,
+            'tags': self.tags
+        }
+
+
+@dataclass
+class Reflection:
+    """Represents the agent's reflection on its actions."""
+    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    action_id: str = ""
+    thought: str = ""
+    success: bool = True
+    lessons_learned: List[str] = field(default_factory=list)
+    improvements: List[str] = field(default_factory=list)
+    timestamp: datetime = field(default_factory=datetime.now)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'id': self.id,
+            'action_id': self.action_id,
+            'thought': self.thought,
+            'success': self.success,
+            'lessons_learned': self.lessons_learned,
+            'improvements': self.improvements,
+            'timestamp': self.timestamp.isoformat()
+        }
+
+
+@dataclass
+class AgentState:
+    """
+    Complete state of the AstraAgent.
+    Tracks everything the agent needs to operate.
+    """
+    # Session info
+    session_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    started_at: datetime = field(default_factory=datetime.now)
+    
+    # Current goal and plan
+    current_goal: Optional[str] = None
+    current_plan: Optional[Plan] = None
+    current_task: Optional[Task] = None
+    current_action: Optional[Action] = None
+    
+    # History
+    action_history: List[Action] = field(default_factory=list)
+    observations: List[Observation] = field(default_factory=list)
+    reflections: List[Reflection] = field(default_factory=list)
+    
+    # Metrics
+    total_actions: int = 0
+    successful_actions: int = 0
+    failed_actions: int = 0
+    total_tokens_used: int = 0
+    iteration_count: int = 0
+    
+    # Context
+    context: Dict[str, Any] = field(default_factory=dict)
+    artifacts_created: List[str] = field(default_factory=list)
+    errors_encountered: List[str] = field(default_factory=list)
+    
+    # Flags
+    is_running: bool = False
+    is_paused: bool = False
+    requires_input: bool = False
+    last_error: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            'session_id': self.session_id,
+            'started_at': self.started_at.isoformat(),
+            'current_goal': self.current_goal,
+            'current_plan': self.current_plan.to_dict() if self.current_plan else None,
+            'current_task': self.current_task.to_dict() if self.current_task else None,
+            'current_action': self.current_action.to_dict() if self.current_action else None,
+            'action_history': [a.to_dict() for a in self.action_history],
+            'observations': [o.to_dict() for o in self.observations],
+            'reflections': [r.to_dict() for r in self.reflections],
+            'metrics': {
+                'total_actions': self.total_actions,
+                'successful_actions': self.successful_actions,
+                'failed_actions': self.failed_actions,
+                'total_tokens_used': self.total_tokens_used,
+                'iteration_count': self.iteration_count,
+                'success_rate': self.success_rate
+            },
+            'artifacts_created': self.artifacts_created,
+            'errors_encountered': self.errors_encountered,
+            'is_running': self.is_running,
+            'is_paused': self.is_paused,
+            'requires_input': self.requires_input,
+            'last_error': self.last_error
+        }
+    
+    @property
+    def success_rate(self) -> float:
+        if self.total_actions == 0:
+            return 0.0
+        return (self.successful_actions / self.total_actions) * 100
+    
+    @property
+    def duration(self) -> float:
+        """Session duration in seconds."""
+        return (datetime.now() - self.started_at).total_seconds()
+    
+    def set_goal(self, goal: str):
+        """Set the current goal and create a new plan."""
+        self.current_goal = goal
+        self.current_plan = Plan(goal=goal)
+    
+    def record_action(self, action: Action):
+        """Record an action in history and update metrics."""
+        self.action_history.append(action)
+        self.total_actions += 1
+        if action.status == ActionStatus.SUCCESS:
+            self.successful_actions += 1
+        elif action.status == ActionStatus.FAILED:
+            self.failed_actions += 1
+            if action.error:
+                self.errors_encountered.append(action.error)
+    
+    def add_observation(self, content: str, source: str = "", importance: int = 5):
+        """Add an observation."""
+        obs = Observation(content=content, source=source, importance=importance)
+        self.observations.append(obs)
+        return obs
+    
+    def add_reflection(self, action_id: str, thought: str, success: bool = True):
+        """Add a reflection on an action."""
+        ref = Reflection(action_id=action_id, thought=thought, success=success)
+        self.reflections.append(ref)
+        return ref
+    
+    def add_artifact(self, path: str):
+        """Record a created artifact."""
+        if path not in self.artifacts_created:
+            self.artifacts_created.append(path)
+    
+    def increment_iteration(self):
+        """Increment the iteration counter."""
+        self.iteration_count += 1
+    
+    def save(self, path: str):
+        """Save state to file."""
+        with open(path, 'w') as f:
+            json.dump(self.to_dict(), f, indent=2)
+    
+    def get_recent_context(self, n: int = 10) -> str:
+        """Get recent actions as context string."""
+        recent = self.action_history[-n:]
+        lines = []
+        for action in recent:
+            status = "[OK]" if action.status == ActionStatus.SUCCESS else "[X]"
+            lines.append(f"[{status}] {action.tool}: {action.thought[:100]}...")
+        return "\n".join(lines)
+    
+    def get_summary(self) -> str:
+        """Get a summary of the current state."""
+        plan_status = ""
+        if self.current_plan:
+            plan_status = f"Plan Progress: {self.current_plan.progress:.1f}%"
+        
+        return f"""
+Session: {self.session_id[:8]}
+Goal: {self.current_goal or 'None'}
+{plan_status}
+Iteration: {self.iteration_count}
+Actions: {self.total_actions} (OK:{self.successful_actions} FAIL:{self.failed_actions})
+Success Rate: {self.success_rate:.1f}%
+Duration: {self.duration:.1f}s
+Artifacts: {len(self.artifacts_created)}
+Status: {'Running' if self.is_running else 'Stopped'}
+""".strip()

package/astra/core/voice.py

@@ -0,0 +1,144 @@
+"""
+AstraAgent Voice Engine
+Integrates Qwen3-TTS for high-quality speech synthesis.
+"""
+
+import os
+import threading
+import logging
+import tempfile
+import time
+from typing import Optional
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# Global flag for dependencies
+HAS_DEPENDENCIES = True
+MISSING_DEPS = []
+
+try:
+    import torch
+except ImportError:
+    HAS_DEPENDENCIES = False
+    MISSING_DEPS.append("torch")
+
+try:
+    import soundfile as sf
+except ImportError:
+    HAS_DEPENDENCIES = False
+    MISSING_DEPS.append("soundfile")
+
+try:
+    import sounddevice as sd
+except ImportError:
+    HAS_DEPENDENCIES = False
+    MISSING_DEPS.append("sounddevice")
+
+try:
+    from qwen_tts import Qwen3TTSModel
+except ImportError:
+    HAS_DEPENDENCIES = False
+    MISSING_DEPS.append("qwen-tts")
+
+
+class VoiceEngine:
+    """
+    Manages Text-to-Speech generation using Qwen3-TTS.
+    """
+    
+    def __init__(self, model_id: str = "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice"):
+        self.model_id = model_id
+        self.model = None
+        self.is_loading = False
+        self.lock = threading.Lock()
+        self.device = "cuda" if HAS_DEPENDENCIES and torch.cuda.is_available() else "cpu"
+        
+    def is_available(self) -> bool:
+        """Check if dependencies are met."""
+        return HAS_DEPENDENCIES
+
+    def get_missing_deps(self) -> list:
+        """Get list of missing dependencies."""
+        return MISSING_DEPS
+
+    def ensure_loaded(self):
+        """Load the model if not already loaded."""
+        if self.model is not None:
+            return
+
+        with self.lock:
+            if self.model is not None:
+                return
+            
+            if not self.is_available():
+                raise ImportError(f"Missing dependencies: {', '.join(self.get_missing_deps())}")
+
+            logger.info(f"Loading Qwen3-TTS model: {self.model_id} on {self.device}...")
+            print(f"Loading AI Voice Model ({self.model_id})... This may take a moment.")
+            
+            try:
+                # Determine dtype based on device
+                dtype = torch.float16 if self.device == "cuda" else torch.float32
+                
+                # Check for Flash Attention 2 support (cuda only usually)
+                attn_impl = "eager" # Default to eager for broader compatibility
+                # if self.device == "cuda":
+                #     attn_impl = "flash_attention_2" 
+                
+                self.model = Qwen3TTSModel.from_pretrained(
+                    self.model_id,
+                    device_map=self.device,
+                    dtype=dtype,
+                    attn_implementation=attn_impl
+                )
+                logger.info("Voice model loaded successfully.")
+                print("✓ AI Voice Model loaded")
+            except Exception as e:
+                logger.error(f"Failed to load voice model: {e}")
+                raise e
+
+    def speak(self, text: str, speaker: str = "Vivian", language: str = "English", block: bool = False):
+        """
+        Generate and play speech for the given text.
+        """
+        if not text:
+            return
+
+        # Run in separate thread if not blocking
+        if not block:
+            threading.Thread(target=self._speak_internal, args=(text, speaker, language)).start()
+        else:
+            self._speak_internal(text, speaker, language)
+
+    def _speak_internal(self, text: str, speaker: str, language: str):
+        try:
+            self.ensure_loaded()
+            
+            # Generate audio
+            # Returns: wavs (list of numpy arrays), sample_rate
+            wavs, sample_rate = self.model.generate_custom_voice(
+                text=text,
+                language=language,
+                speaker=speaker
+            )
+            
+            if wavs and len(wavs) > 0:
+                audio_data = wavs[0]
+                
+                # Play audio
+                sd.play(audio_data, sample_rate)
+                sd.wait()
+                
+        except Exception as e:
+            logger.error(f"Speech generation error: {e}")
+            print(f"Speech Error: {e}")
+
+# Global instance
+_engine = None
+
+def get_engine():
+    global _engine
+    if _engine is None:
+        _engine = VoiceEngine()
+    return _engine

package/astra/llm/__init__.py

@@ -0,0 +1,32 @@
+"""LLM Provider for AstraAgent - Multi-provider support."""
+
+# Re-export everything from providers module for backward compatibility
+from astra.llm.providers import (
+    Message,
+    LLMResponse,
+    LLMProvider,
+    LocalServerProvider,
+    OpenAIProvider,
+    GeminiProvider,
+    AnthropicProvider,
+    OpenRouterProvider,
+    GroqProvider,
+    PROVIDERS,
+    create_provider,
+    get_provider_info,
+)
+
+__all__ = [
+    "Message",
+    "LLMResponse",
+    "LLMProvider",
+    "LocalServerProvider",
+    "OpenAIProvider",
+    "GeminiProvider",
+    "AnthropicProvider",
+    "OpenRouterProvider",
+    "GroqProvider",
+    "PROVIDERS",
+    "create_provider",
+    "get_provider_info",
+]