Release v4.4.3

Author: MervinPraison

.gitignore

@@ -84,4 +84,5 @@ issue_details.json
 .mcpregistry_*
 
 *.log
-.internal
+.internal
+.praisonai

docker/Dockerfile.chat

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.4.2" \
+    "praisonai>=4.4.3" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 

docker/Dockerfile.dev

@@ -20,7 +20,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.4.2" \
+    "praisonai>=4.4.3" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \

docker/Dockerfile.ui

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     praisonai_tools \
-    "praisonai>=4.4.2" \
+    "praisonai>=4.4.3" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

src/praisonai-agents/praisonaiagents/config/feature_configs.py

@@ -33,6 +33,9 @@
 from typing import Dict, List, Any, Optional, Callable, Tuple, Union
 from enum import Enum
 
+# Import AutonomyConfig from canonical location (no circular dep)
+from ..agent.autonomy import AutonomyConfig
+
 
 class MemoryBackend(str, Enum):
     """Memory storage backends."""
@@ -953,54 +956,6 @@ class AutonomyLevel(str, Enum):
     AUTO_EDIT = "auto_edit"
     FULL_AUTO = "full_auto"
 
-
-@dataclass
-class AutonomyConfig:
-    """
-    Configuration for agent autonomy behavior.
-    
-    Controls escalation, doom-loop detection, and approval policies.
-    
-    Usage:
-        # Simple enable
-        Agent(autonomy=True)
-        
-        # With config
-        Agent(autonomy=AutonomyConfig(
-            level="auto_edit",
-            escalation_enabled=True,
-            doom_loop_detection=True,
-            max_consecutive_failures=3,
-        ))
-    """
-    # Autonomy level
-    level: Union[str, AutonomyLevel] = AutonomyLevel.SUGGEST
-    
-    # Escalation pipeline
-    escalation_enabled: bool = True
-    escalation_threshold: int = 3
-    
-    # Doom loop detection
-    doom_loop_detection: bool = True
-    max_consecutive_failures: int = 3
-    
-    # Approval policies
-    require_approval_for_writes: bool = True
-    require_approval_for_shell: bool = True
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary."""
-        return {
-            "level": self.level.value if isinstance(self.level, AutonomyLevel) else self.level,
-            "escalation_enabled": self.escalation_enabled,
-            "escalation_threshold": self.escalation_threshold,
-            "doom_loop_detection": self.doom_loop_detection,
-            "max_consecutive_failures": self.max_consecutive_failures,
-            "require_approval_for_writes": self.require_approval_for_writes,
-            "require_approval_for_shell": self.require_approval_for_shell,
-        }
-
-
 # Type aliases for Union types used in Agent.__init__
 MemoryParam = Union[bool, MemoryConfig, Any]  # Any = MemoryManager instance
 KnowledgeParam = Union[bool, List[str], KnowledgeConfig, Any]  # Any = KnowledgeBase instance
@@ -1014,7 +969,7 @@ def to_dict(self) -> Dict[str, Any]:
 CachingParam = Union[bool, CachingConfig]
 HooksParam = Union[List[Any], HooksConfig]
 SkillsParam = Union[List[str], SkillsConfig]
-AutonomyParam = Union[bool, Dict[str, Any], AutonomyConfig]
+AutonomyParam = Union[bool, Dict[str, Any], "AutonomyConfig"]
 
 
 # =============================================================================

src/praisonai-agents/praisonaiagents/context/manager.py

@@ -24,7 +24,8 @@
 from enum import Enum
 
 from .models import (
-    ContextLedger, BudgetAllocation, OptimizerStrategy, OptimizationResult
+    ContextLedger, BudgetAllocation, OptimizerStrategy, OptimizationResult,
+    ContextConfig as ManagerConfig  # Deprecated alias for backward compatibility
 )
 from .tokens import estimate_tokens_heuristic, estimate_messages_tokens, estimate_message_tokens
 from .budgeter import ContextBudgeter
@@ -288,180 +289,6 @@ def to_dict(self) -> Dict[str, Any]:
             "budget": self.budget.to_dict() if self.budget else None,
         }
 
-
-@dataclass
-class ManagerConfig:
-    """
-    Complete configuration for ContextManager.
-    
-    Consolidates all context management settings with proper precedence.
-    """
-    # Auto-compaction
-    auto_compact: bool = True
-    compact_threshold: float = 0.8
-    strategy: OptimizerStrategy = OptimizerStrategy.SMART
-    
-    # Compression benefit check
-    compression_min_gain_pct: float = 5.0
-    compression_max_attempts: int = 3
-    
-    # Budget
-    output_reserve: int = 8000
-    history_ratio: float = 0.6
-    default_tool_output_max: int = 10000
-    
-    # Per-tool budgets
-    tool_budgets: Dict[str, PerToolBudget] = field(default_factory=dict)
-    protected_tools: List[str] = field(default_factory=list)
-    
-    # LLM-powered summarization
-    llm_summarize: bool = False  # Enable LLM-powered summarization
-    
-    # Smart tool output summarization
-    smart_tool_summarize: bool = True  # Summarize large tool outputs using LLM before truncating
-    tool_summarize_limits: Dict[str, int] = field(default_factory=dict)  # Per-tool min_chars_to_summarize
-    
-    # Estimation
-    estimation_mode: EstimationMode = EstimationMode.HEURISTIC
-    log_estimation_mismatch: bool = False
-    mismatch_threshold_pct: float = 15.0
-    
-    # Monitoring
-    monitor_enabled: bool = False
-    monitor_path: str = "./context.txt"
-    monitor_format: Literal["human", "json"] = "human"
-    monitor_frequency: Literal["turn", "tool_call", "manual", "overflow"] = "turn"
-    monitor_write_mode: Literal["sync", "async"] = "sync"
-    redact_sensitive: bool = True
-    snapshot_timing: Literal["pre_optimization", "post_optimization", "both"] = "post_optimization"
-    
-    # Path validation
-    allow_absolute_paths: bool = False
-    
-    # Pruning
-    prune_after_tokens: int = 40000
-    keep_recent_turns: int = 5
-    
-    # Source tracking
-    source: str = "defaults"  # defaults, env, config_file, cli
-    
-    def to_dict(self) -> Dict[str, Any]:
-        result = {
-            "auto_compact": self.auto_compact,
-            "compact_threshold": self.compact_threshold,
-            "strategy": self.strategy.value,
-            "compression_min_gain_pct": self.compression_min_gain_pct,
-            "compression_max_attempts": self.compression_max_attempts,
-            "output_reserve": self.output_reserve,
-            "history_ratio": self.history_ratio,
-            "default_tool_output_max": self.default_tool_output_max,
-            "tool_budgets": {k: v.to_dict() for k, v in self.tool_budgets.items()},
-            "protected_tools": self.protected_tools,
-            "estimation_mode": self.estimation_mode.value,
-            "log_estimation_mismatch": self.log_estimation_mismatch,
-            "mismatch_threshold_pct": self.mismatch_threshold_pct,
-            "monitor_enabled": self.monitor_enabled,
-            "monitor_path": self.monitor_path,
-            "monitor_format": self.monitor_format,
-            "monitor_frequency": self.monitor_frequency,
-            "monitor_write_mode": self.monitor_write_mode,
-            "redact_sensitive": self.redact_sensitive,
-            "snapshot_timing": self.snapshot_timing,
-            "allow_absolute_paths": self.allow_absolute_paths,
-            "prune_after_tokens": self.prune_after_tokens,
-            "keep_recent_turns": self.keep_recent_turns,
-            "llm_summarize": self.llm_summarize,
-            "smart_tool_summarize": self.smart_tool_summarize,
-            "tool_summarize_limits": self.tool_summarize_limits,
-            "source": self.source,
-        }
-        return result
-    
-    @classmethod
-    def from_env(cls) -> "ManagerConfig":
-        """Load config from environment variables."""
-        import os
-        
-        def get_bool(key: str, default: bool) -> bool:
-            val = os.getenv(key, str(default)).lower()
-            return val in ("true", "1", "yes", "on")
-        
-        def get_float(key: str, default: float) -> float:
-            try:
-                return float(os.getenv(key, str(default)))
-            except ValueError:
-                return default
-        
-        def get_int(key: str, default: int) -> int:
-            try:
-                return int(os.getenv(key, str(default)))
-            except ValueError:
-                return default
-        
-        strategy_str = os.getenv("PRAISONAI_CONTEXT_STRATEGY", "smart")
-        try:
-            strategy = OptimizerStrategy(strategy_str)
-        except ValueError:
-            strategy = OptimizerStrategy.SMART
-        
-        estimation_str = os.getenv("PRAISONAI_CONTEXT_ESTIMATION_MODE", "heuristic")
-        try:
-            estimation_mode = EstimationMode(estimation_str)
-        except ValueError:
-            estimation_mode = EstimationMode.HEURISTIC
-        
-        return cls(
-            auto_compact=get_bool("PRAISONAI_CONTEXT_AUTO_COMPACT", True),
-            compact_threshold=get_float("PRAISONAI_CONTEXT_THRESHOLD", 0.8),
-            strategy=strategy,
-            compression_min_gain_pct=get_float("PRAISONAI_CONTEXT_COMPRESSION_MIN_GAIN", 5.0),
-            compression_max_attempts=get_int("PRAISONAI_CONTEXT_COMPRESSION_MAX_ATTEMPTS", 3),
-            output_reserve=get_int("PRAISONAI_CONTEXT_OUTPUT_RESERVE", 8000),
-            default_tool_output_max=get_int("PRAISONAI_CONTEXT_TOOL_OUTPUT_MAX", 10000),
-            estimation_mode=estimation_mode,
-            log_estimation_mismatch=get_bool("PRAISONAI_CONTEXT_LOG_MISMATCH", False),
-            monitor_enabled=get_bool("PRAISONAI_CONTEXT_MONITOR", False),
-            monitor_path=os.getenv("PRAISONAI_CONTEXT_MONITOR_PATH", "./context.txt"),
-            monitor_format=os.getenv("PRAISONAI_CONTEXT_MONITOR_FORMAT", "human"),
-            monitor_frequency=os.getenv("PRAISONAI_CONTEXT_MONITOR_FREQUENCY", "turn"),
-            monitor_write_mode=os.getenv("PRAISONAI_CONTEXT_MONITOR_WRITE_MODE", "sync"),
-            redact_sensitive=get_bool("PRAISONAI_CONTEXT_REDACT", True),
-            source="env",
-        )
-    
-    def merge(self, **overrides) -> "ManagerConfig":
-        """Create new config with overrides applied."""
-        current = self.to_dict()
-        
-        for key, value in overrides.items():
-            if value is not None and key in current:
-                current[key] = value
-        
-        # Handle enum conversions
-        if isinstance(current.get("strategy"), str):
-            try:
-                current["strategy"] = OptimizerStrategy(current["strategy"])
-            except ValueError:
-                current["strategy"] = OptimizerStrategy.SMART
-        
-        if isinstance(current.get("estimation_mode"), str):
-            try:
-                current["estimation_mode"] = EstimationMode(current["estimation_mode"])
-            except ValueError:
-                current["estimation_mode"] = EstimationMode.HEURISTIC
-        
-        # Reconstruct tool budgets
-        tool_budgets = {}
-        for name, budget_dict in current.get("tool_budgets", {}).items():
-            if isinstance(budget_dict, dict):
-                tool_budgets[name] = PerToolBudget(**budget_dict)
-            elif isinstance(budget_dict, PerToolBudget):
-                tool_budgets[name] = budget_dict
-        current["tool_budgets"] = tool_budgets
-        
-        return ManagerConfig(**current)
-
-
 class ContextManager:
     """
     Unified facade for context management.