Release v4.5.29

MervinPraison · MervinPraison · commit 8555b5ad6905 · 2026-03-09T06:18:18.000Z
diff --git a/docker/Dockerfile.chat b/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.5.28" \
+    "praisonai>=4.5.29" \
     "praisonai[chat]" \
     "embedchain[github,youtube]"
 
diff --git a/docker/Dockerfile.dev b/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.5.28" \
+    "praisonai>=4.5.29" \
     "praisonai[ui]" \
     "praisonai[chat]" \
     "praisonai[realtime]" \
diff --git a/docker/Dockerfile.ui b/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.5.28" \
+    "praisonai>=4.5.29" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 
diff --git a/src/praisonai-agents/AGENTS.md b/src/praisonai-agents/AGENTS.md
@@ -123,6 +123,8 @@ Pattern: Each major module has a protocols.py file
 - Protocols define WHAT (interface contract)
 - Adapters implement HOW (concrete implementation)
 - Naming: XProtocol for interfaces, XAdapter for implementations
+  (ALWAYS suffix with "Protocol" — never use bare concept names like TraceSink)
+- File placement: All protocols live in protocols.py within their module
 - Users can implement any protocol for custom behavior
 ```
 
@@ -286,9 +288,19 @@ save() / load()  # Disk persistence (NOT store)
 # Configuration
 class XConfig:   # Configuration dataclass (MemoryConfig, HooksConfig)
 
-# Protocols
-class XProtocol(Protocol):  # Abstract interface
-class XAdapter:             # Implementation
+# Protocols — ALWAYS suffix with "Protocol"
+class XProtocol(Protocol):  # Abstract interface (TraceSinkProtocol, MemoryProtocol)
+class XAdapter:             # Concrete implementation (ChromaAdapter, FileAdapter)
+
+# ✅ CORRECT protocol naming:
+class MemoryProtocol(Protocol): ...        # Clear it's a protocol
+class SessionStoreProtocol(Protocol): ...  # Descriptive + Protocol suffix
+class TraceSinkProtocol(Protocol): ...     # In protocols.py + suffixed
+
+# ❌ WRONG protocol naming:
+class TraceSink(Protocol): ...     # Missing Protocol suffix — ambiguous
+class IMemory(Protocol): ...       # TypeScript convention, not Python
+class MemoryBase(Protocol): ...    # "Base" implies ABC, not Protocol
 
 # Execution
 run()            # Synchronous, blocking
diff --git a/src/praisonai-agents/pyproject.toml b/src/praisonai-agents/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "1.5.28"
+version = "1.5.29"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 readme = "README.md"
 requires-python = ">=3.10"
diff --git a/src/praisonai-agents/uv.lock b/src/praisonai-agents/uv.lock
diff --git a/src/praisonai/praisonai.rb b/src/praisonai/praisonai.rb
@@ -3,8 +3,8 @@ class Praisonai < Formula
   
     desc "AI tools for various AI applications"
     homepage "https://github.com/MervinPraison/PraisonAI"
-    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v4.5.28.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v4.5.28.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v4.5.29.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v4.5.29.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "python@3.11"
diff --git a/src/praisonai/praisonai/deploy.py b/src/praisonai/praisonai/deploy.py
@@ -57,7 +57,7 @@ def create_dockerfile(self):
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==4.5.28 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==4.5.29 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             
diff --git a/src/praisonai/praisonai/gateway/server.py b/src/praisonai/praisonai/gateway/server.py
@@ -815,22 +815,76 @@ def _resolve(obj):
         return _resolve(raw)
 
     def _create_agents_from_config(self, agents_cfg: Dict[str, Dict[str, Any]]) -> None:
-        """Create and register Agent instances from the agents section of gateway.yaml."""
+        """Create and register Agent instances from the agents section of gateway.yaml.
+        
+        Supports all agent configuration options including:
+        - tools: List of tool names to resolve via ToolResolver
+        - tool_choice: Tool selection mode ('auto', 'required', 'none')
+        - reflection: Enable reflection/interactive mode (default: True)
+        - allow_delegation: Allow task delegation
+        - role: Agent role (CrewAI-style)
+        - goal: Agent goal (CrewAI-style)
+        - backstory: Agent backstory (CrewAI-style)
+        """
         from praisonaiagents import Agent
 
+        # G1: Resolve tool names to callables (same pattern as agents_generator)
+        tool_resolver = None
+        try:
+            from praisonai.tool_resolver import ToolResolver
+            tool_resolver = ToolResolver()
+        except ImportError:
+            logger.debug("ToolResolver not available, agents will have no tools")
+
         for agent_id, agent_def in agents_cfg.items():
             instructions = agent_def.get("instructions", "")
             model = agent_def.get("model", None)
             memory = agent_def.get("memory", False)
+            
+            # G4: Support role/goal/backstory for CrewAI-style agents
+            role = agent_def.get("role", None)
+            goal = agent_def.get("goal", None)
+            backstory = agent_def.get("backstory", None)
+            
+            # G1: Resolve tools from YAML config
+            agent_tools = []
+            yaml_tool_names = agent_def.get("tools", [])
+            if yaml_tool_names and tool_resolver:
+                for tool_name in yaml_tool_names:
+                    if not tool_name or not isinstance(tool_name, str):
+                        continue
+                    tool_name = tool_name.strip()
+                    resolved = tool_resolver.resolve(tool_name)
+                    if resolved:
+                        agent_tools.append(resolved)
+                        logger.debug(f"Resolved tool '{tool_name}' for agent '{agent_id}'")
+                    else:
+                        logger.warning(f"Tool '{tool_name}' not found for agent '{agent_id}'")
+            
+            # Additional agent options from YAML
+            tool_choice = agent_def.get("tool_choice", None)
+            reflection = agent_def.get("reflection", True)  # Default: enable reflection/interactive mode
+            allow_delegation = agent_def.get("allow_delegation", False)
 
             agent = Agent(
                 name=agent_id,
                 instructions=instructions,
                 llm=model,
                 memory=memory,
+                tools=agent_tools if agent_tools else None,
+                reflection=reflection,
+                allow_delegation=allow_delegation,
+                role=role,
+                goal=goal,
+                backstory=backstory,
             )
+            
+            # Store tool_choice for later use in chat()
+            if tool_choice:
+                agent._yaml_tool_choice = tool_choice
+            
             self.register_agent(agent, agent_id=agent_id)
-            logger.info(f"Created agent '{agent_id}' (model={model})")
+            logger.info(f"Created agent '{agent_id}' (model={model}, tools={len(agent_tools)}, reflection={reflection})")
 
     def _determine_routing_context(
         self, channel_type: str, message_metadata: Dict[str, Any]
diff --git a/src/praisonai/praisonai/version.py b/src/praisonai/praisonai/version.py
@@ -1 +1 @@
-__version__ = "4.5.28"
+__version__ = "4.5.29"
diff --git a/src/praisonai/pyproject.toml b/src/praisonai/pyproject.toml
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=1.5.28",
+    "praisonaiagents>=1.5.29",
     "python-dotenv>=0.19.0",
     "litellm>=1.81.0",
     "PyYAML>=6.0",
diff --git a/src/praisonai/tests/unit/test_gateway_tools.py b/src/praisonai/tests/unit/test_gateway_tools.py
@@ -0,0 +1,209 @@
+"""
+TDD Tests for Gateway Tool Resolution Gaps (G1, G2, G3).
+
+Tests the fixes for tool resolution in gateway agent creation.
+"""
+
+# Mocks available if needed for future tests
+
+
+class TestGapG1GatewayToolResolution:
+    """Test Gap G1: Gateway _create_agents_from_config() tool resolution."""
+
+    def test_gateway_creates_agent_with_tools_from_yaml(self):
+        """Gateway should resolve tools from YAML config."""
+        from praisonai.gateway import WebSocketGateway
+        
+        gw = WebSocketGateway()
+        
+        # Mock config with tools
+        agents_cfg = {
+            "researcher": {
+                "instructions": "You are a researcher",
+                "model": "gpt-4o-mini",
+                "tools": ["internet_search", "get_current_time"],
+            }
+        }
+        
+        # Create agents from config
+        gw._create_agents_from_config(agents_cfg)
+        
+        # Verify agent was created
+        agent = gw.get_agent("researcher")
+        assert agent is not None
+        assert agent.name == "researcher"
+        # Tools should be resolved (may be empty if ToolResolver can't find them)
+        # The important thing is no error was raised
+
+    def test_gateway_handles_missing_tool_gracefully(self):
+        """Gateway should log warning for missing tools but not fail."""
+        from praisonai.gateway import WebSocketGateway
+        
+        gw = WebSocketGateway()
+        
+        agents_cfg = {
+            "test_agent": {
+                "instructions": "Test agent",
+                "tools": ["nonexistent_tool_xyz"],
+            }
+        }
+        
+        # Should not raise
+        gw._create_agents_from_config(agents_cfg)
+        
+        agent = gw.get_agent("test_agent")
+        assert agent is not None
+
+    def test_gateway_agent_has_reflection_enabled_by_default(self):
+        """Gateway agents should have reflection=True by default."""
+        from praisonai.gateway import WebSocketGateway
+        
+        gw = WebSocketGateway()
+        
+        agents_cfg = {
+            "assistant": {
+                "instructions": "You are helpful",
+            }
+        }
+        
+        gw._create_agents_from_config(agents_cfg)
+        
+        agent = gw.get_agent("assistant")
+        assert agent is not None
+        # self_reflect should be True by default (set via reflection param)
+        assert getattr(agent, "self_reflect", None) is True
+
+    def test_gateway_supports_tool_choice_from_yaml(self):
+        """Gateway should store tool_choice from YAML config."""
+        from praisonai.gateway import WebSocketGateway
+        
+        gw = WebSocketGateway()
+        
+        agents_cfg = {
+            "researcher": {
+                "instructions": "Research assistant",
+                "tools": ["internet_search"],
+                "tool_choice": "required",
+            }
+        }
+        
+        gw._create_agents_from_config(agents_cfg)
+        
+        agent = gw.get_agent("researcher")
+        assert agent is not None
+        # tool_choice should be stored as _yaml_tool_choice
+        assert getattr(agent, "_yaml_tool_choice", None) == "required"
+
+    def test_gateway_supports_reflection_override(self):
+        """Gateway should allow reflection to be disabled via YAML."""
+        from praisonai.gateway import WebSocketGateway
+        
+        gw = WebSocketGateway()
+        
+        agents_cfg = {
+            "simple_agent": {
+                "instructions": "Simple agent",
+                "reflection": False,
+            }
+        }
+        
+        gw._create_agents_from_config(agents_cfg)
+        
+        agent = gw.get_agent("simple_agent")
+        assert agent is not None
+        assert getattr(agent, "self_reflect", True) is False
+
+
+class TestGapG1ToolResolver:
+    """Test ToolResolver integration."""
+
+    def test_tool_resolver_resolve_many_exists(self):
+        """ToolResolver should have resolve_many method."""
+        from praisonai.tool_resolver import ToolResolver
+        
+        resolver = ToolResolver()
+        
+        assert hasattr(resolver, "resolve_many")
+        assert callable(resolver.resolve_many)
+
+    def test_tool_resolver_resolve_returns_callable_or_none(self):
+        """ToolResolver.resolve should return callable or None."""
+        from praisonai.tool_resolver import ToolResolver
+        
+        resolver = ToolResolver()
+        
+        # Known tool should return callable
+        result = resolver.resolve("internet_search")
+        # May be None if tool not available, but should not raise
+        if result is not None:
+            assert callable(result)
+        
+        # Unknown tool should return None
+        result = resolver.resolve("nonexistent_tool_xyz_123")
+        assert result is None
+
+
+class TestGapG2ProviderDefaultTools:
+    """Test Gap G2: PraisonAIUI provider default tools."""
+
+    def test_provider_agent_kwargs_include_reflection(self):
+        """Provider should set reflection=True by default."""
+        # This tests the pattern, not the actual provider (which is in PraisonAIUI)
+        default_kwargs = {
+            "name": "Assistant",
+            "instructions": "You are a helpful assistant.",
+            "memory": True,
+            "reflection": True,
+        }
+        
+        assert default_kwargs["reflection"] is True
+
+
+class TestGapG3ChannelBotTools:
+    """Test Gap G3: Channel bot agent tools."""
+
+    def test_channel_bot_agent_pattern_includes_tools(self):
+        """Channel bot agent creation pattern should include tools."""
+        # This tests the pattern, not the actual channel bot (which is in PraisonAIUI)
+        from praisonai.tool_resolver import ToolResolver
+        
+        resolver = ToolResolver()
+        agent_tools = resolver.resolve_many(["internet_search", "get_current_time"])
+        
+        # Should return a list (may be empty if tools not available)
+        assert isinstance(agent_tools, list)
+
+
+class TestToolResolverIntegration:
+    """Integration tests for ToolResolver with gateway."""
+
+    def test_full_gateway_agent_creation_with_tools(self):
+        """Full integration test: gateway creates agent with resolved tools."""
+        from praisonai.gateway import WebSocketGateway
+        from praisonai.tool_resolver import ToolResolver
+        
+        # First verify ToolResolver works
+        resolver = ToolResolver()
+        tools = resolver.resolve_many(["internet_search"])
+        
+        # Create gateway and agent
+        gw = WebSocketGateway()
+        agents_cfg = {
+            "test_researcher": {
+                "instructions": "Research assistant with tools",
+                "model": "gpt-4o-mini",
+                "tools": ["internet_search"],
+                "reflection": True,
+            }
+        }
+        
+        gw._create_agents_from_config(agents_cfg)
+        
+        agent = gw.get_agent("test_researcher")
+        assert agent is not None
+        assert agent.name == "test_researcher"
+        
+        # If tools were resolved, agent should have them
+        if tools:
+            assert agent.tools is not None
+            assert len(agent.tools) > 0
diff --git a/src/praisonai/uv.lock b/src/praisonai/uv.lock

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-__version__ = "4.5.28"`
	`1`	`+__version__ = "4.5.29"`