Release v3.9.35

Author: MervinPraison

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>=3.9.34" \
+    "praisonai>=3.9.35" \
     "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>=3.9.34" \
+    "praisonai>=3.9.35" \
     "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>=3.9.34" \
+    "praisonai>=3.9.35" \
     "praisonai[ui]" \
     "praisonai[crewai]"
 

src/praisonai-agents/praisonaiagents/__init__.py

@@ -534,7 +534,15 @@ def _stub(*args, **kwargs):
         _lazy_cache[name] = result
         return result
 
-    # Context management config (already exists)
+    # Context management config
+    elif name == "ContextConfig":
+        from .context.models import ContextConfig
+        _lazy_cache[name] = ContextConfig
+        return ContextConfig
+    elif name == "OptimizerStrategy":
+        from .context.models import OptimizerStrategy
+        _lazy_cache[name] = OptimizerStrategy
+        return OptimizerStrategy
     elif name == "ManagerConfig":
         from .context.manager import ManagerConfig
         _lazy_cache[name] = ManagerConfig

src/praisonai-agents/praisonaiagents/agent/agent.py

@@ -1220,12 +1220,38 @@ def context_manager(self):
                 agent_name=self.name or "Agent",
             )
         elif isinstance(self._context_param, ManagerConfig):
-            # Use provided config
+            # Use provided ManagerConfig
             self._context_manager = ContextManager(
                 model=self.llm if isinstance(self.llm, str) else "gpt-4o-mini",
                 config=self._context_param,
                 agent_name=self.name or "Agent",
             )
+        elif hasattr(self._context_param, 'auto_compact') and hasattr(self._context_param, 'tool_output_max'):
+            # ContextConfig from YAML - convert to ManagerConfig
+            try:
+                from ..context.models import ContextConfig as _ContextConfig
+                if isinstance(self._context_param, _ContextConfig):
+                    # Build ManagerConfig from ContextConfig fields
+                    manager_config = ManagerConfig(
+                        auto_compact=self._context_param.auto_compact,
+                        compact_threshold=self._context_param.compact_threshold,
+                        strategy=self._context_param.strategy,
+                        output_reserve=self._context_param.output_reserve,
+                        default_tool_output_max=self._context_param.tool_output_max,  # Map field name
+                        protected_tools=list(self._context_param.protected_tools),
+                        keep_recent_turns=self._context_param.keep_recent_turns,
+                        monitor_enabled=self._context_param.monitor.enabled if self._context_param.monitor else False,
+                    )
+                    self._context_manager = ContextManager(
+                        model=self.llm if isinstance(self.llm, str) else "gpt-4o-mini",
+                        config=manager_config,
+                        agent_name=self.name or "Agent",
+                    )
+                else:
+                    self._context_manager = None
+            except Exception as e:
+                logging.debug(f"ContextConfig conversion failed: {e}")
+                self._context_manager = None
         elif hasattr(self._context_param, 'process'):
             # Already a ContextManager instance
             self._context_manager = self._context_param
@@ -2920,11 +2946,28 @@ def execute_tool(self, function_name, arguments):
         return self._execute_tool_with_context(function_name, arguments, state)
 
     def _execute_tool_with_context(self, function_name, arguments, state):
-        """Execute tool within injection context."""
+        """Execute tool within injection context, with optional output truncation."""
         from ..tools.injected import with_injection_context
 
         with with_injection_context(state):
-            return self._execute_tool_impl(function_name, arguments)
+            result = self._execute_tool_impl(function_name, arguments)
+        
+        # Apply context-aware truncation if context management is enabled
+        # This prevents tool outputs (e.g., search results) from exploding the context
+        if self.context_manager and result:
+            try:
+                truncated = self._truncate_tool_output(function_name, str(result))
+                if len(truncated) < len(str(result)):
+                    logging.debug(f"Truncated {function_name} output from {len(str(result))} to {len(truncated)} chars")
+                    # Return truncated string if significantly shorter
+                    if isinstance(result, dict):
+                        # Keep dict structure but may have truncated string representation
+                        return result  # Let the string version be truncated at display time
+                    return truncated
+            except Exception as e:
+                logging.debug(f"Tool truncation skipped: {e}")
+        
+        return result
 
     def _execute_tool_impl(self, function_name, arguments):
         """Internal tool execution implementation."""

src/praisonai-agents/praisonaiagents/workflows/workflows.py

@@ -21,6 +21,7 @@
 
 import os
 import re
+import json
 import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Callable, Tuple, Union
@@ -34,6 +35,49 @@
 logger = logging.getLogger(__name__)
 
 
+def _parse_json_output(output: Any, step_name: str = "step") -> Any:
+    """
+    Parse JSON from LLM output if it's a string.
+    
+    Handles:
+    - Direct JSON strings: '{"key": "value"}'
+    - Markdown code blocks: ```json\n{"key": "value"}\n```
+    
+    Returns:
+        Parsed dict/list if successful, original output otherwise
+    """
+    if not isinstance(output, str) or not output:
+        return output
+    
+    # Try direct JSON parse first
+    try:
+        return json.loads(output)
+    except json.JSONDecodeError:
+        pass
+    
+    # Try extracting from markdown code block
+    json_match = re.search(r'```(?:json)?\s*\n?([\s\S]*?)\n?```', output)
+    if json_match:
+        try:
+            return json.loads(json_match.group(1).strip())
+        except json.JSONDecodeError:
+            pass
+    
+    # Try finding JSON object/array in text
+    # Look for {...} or [...]
+    for pattern in [r'(\{[^}]+\})', r'(\[[^\]]+\])']:
+        match = re.search(pattern, output)
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except json.JSONDecodeError:
+                continue
+    
+    # Return original if can't parse
+    logger.debug(f"Could not parse JSON from step '{step_name}' output")
+    return output
+
+
 @dataclass
 class WorkflowContext:
     """Context passed to step handlers. Contains all information about the current workflow state."""
@@ -1206,6 +1250,10 @@ def run(
 
                         output = step.agent.chat(action, **chat_kwargs)
 
+                        # Parse JSON output if output_json was requested and output is a string
+                        if step_output_json and output and isinstance(output, str):
+                            output = _parse_json_output(output, step.name)
+                        
                         # Handle output_pydantic if present
                         output_pydantic = getattr(step, 'output_pydantic', None)
                         if output_pydantic and output:
@@ -1257,6 +1305,11 @@ def run(
 
                         output = temp_agent.chat(action, stream=stream)
 
+                        # Parse JSON output if output_json was requested
+                        step_output_json = getattr(step, '_output_json', None)
+                        if step_output_json and output and isinstance(output, str):
+                            output = _parse_json_output(output, step.name)
+                        
                 except Exception as e:
                     step_error = e
                     output = f"Error: {e}"
@@ -1342,6 +1395,26 @@ def run(
             var_name = step.output_variable or f"{step.name}_output"
             all_variables[var_name] = output
 
+            # Validate output and warn about issues
+            if output is None:
+                logger.warning(f"⚠️  Step '{step.name}': Output is None. Agent may not have returned expected format.")
+                if verbose:
+                    print(f"⚠️  WARNING: Step '{step.name}' output is None!")
+            else:
+                # Check type against output_json schema if defined
+                expected_schema = getattr(step, '_output_json', None)
+                if expected_schema and isinstance(expected_schema, dict):
+                    expected_type = expected_schema.get('type')
+                    actual_type = type(output).__name__
+                    if expected_type == 'object' and not isinstance(output, dict):
+                        logger.warning(f"⚠️  Step '{step.name}': Expected object/dict, got {actual_type}")
+                        if verbose:
+                            print(f"⚠️  Step '{step.name}': Expected 'object', received '{actual_type}'")
+                    elif expected_type == 'array' and not isinstance(output, list):
+                        logger.warning(f"⚠️  Step '{step.name}': Expected array/list, got {actual_type}")
+                        if verbose:
+                            print(f"⚠️  Step '{step.name}': Expected 'array', received '{actual_type}'")
+            
             i += 1
 
         # Update workflow status
@@ -1399,33 +1472,12 @@ async def arun(
         return await self.astart(input, llm, verbose)
 
     def _normalize_steps(self) -> List['WorkflowStep']:
-        """Convert mixed steps (Agent, function, WorkflowStep) to WorkflowStep list."""
-        normalized = []
-        
-        for i, step in enumerate(self.steps):
-            if isinstance(step, WorkflowStep):
-                normalized.append(step)
-            elif callable(step):
-                # It's a function - wrap as handler
-                normalized.append(WorkflowStep(
-                    name=getattr(step, '__name__', f'step_{i+1}'),
-                    handler=step
-                ))
-            elif hasattr(step, 'chat'):
-                # It's an Agent - wrap with agent reference
-                normalized.append(WorkflowStep(
-                    name=getattr(step, 'name', f'agent_{i+1}'),
-                    agent=step,
-                    action="{{input}}"
-                ))
-            else:
-                # Unknown type - try to use as string action
-                normalized.append(WorkflowStep(
-                    name=f'step_{i+1}',
-                    action=str(step)
-                ))
+        """Convert mixed steps (Agent, function, WorkflowStep) to WorkflowStep list.
         
-        return normalized
+        This method uses _normalize_single_step to ensure consistent normalization
+        and avoid duplicated code paths (DRY principle).
+        """
+        return [self._normalize_single_step(step, i) for i, step in enumerate(self.steps)]
 
     def _create_plan(self, input: str, model: str, verbose: bool) -> Optional[str]:
         """Create an execution plan for the workflow using LLM.
@@ -1608,6 +1660,11 @@ def _execute_single_step_internal(
                         action = f"{action}\n\nContext from previous step:\n{previous_output}"
                 action = action.replace("{{input}}", input)
                 output = normalized.agent.chat(action, stream=stream)
+                
+                # Parse JSON output if output_json was requested
+                step_output_json = getattr(normalized, '_output_json', None)
+                if step_output_json and output and isinstance(output, str):
+                    output = _parse_json_output(output, normalized.name)
             except Exception as e:
                 output = f"Error: {e}"
         elif normalized.action:
@@ -1633,6 +1690,11 @@ def _execute_single_step_internal(
                         action = f"{action}\n\nContext from previous step:\n{previous_output}"
 
                 output = temp_agent.chat(action, stream=stream)
+                
+                # Parse JSON output if output_json was requested
+                step_output_json = getattr(normalized, '_output_json', None)
+                if step_output_json and output and isinstance(output, str):
+                    output = _parse_json_output(output, normalized.name)
             except Exception as e:
                 output = f"Error: {e}"
 
@@ -1850,6 +1912,32 @@ def execute_item(idx_item_tuple):
         all_variables["loop_outputs"] = outputs  # Also keep for backward compatibility
         combined_output = "\n".join(str(o) for o in outputs) if outputs else ""
 
+        # Validate outputs and warn about issues
+        none_count = sum(1 for o in outputs if o is None)
+        if none_count > 0:
+            logger.warning(f"⚠️  Loop '{output_var_name}': {none_count}/{len(outputs)} outputs are None. "
+                          f"Check if agent returned expected format.")
+            if verbose:
+                print(f"⚠️  WARNING: {none_count}/{len(outputs)} loop outputs are None!")
+        
+        # Check for type consistency
+        if outputs and len(outputs) > 0:
+            expected_type = loop_step.step._output_json if hasattr(loop_step.step, '_output_json') else None
+            if expected_type:
+                expected_schema_type = expected_type.get('type') if isinstance(expected_type, dict) else None
+                for i, o in enumerate(outputs):
+                    if o is None:
+                        continue
+                    actual_type = type(o).__name__
+                    if expected_schema_type == 'object' and not isinstance(o, dict):
+                        logger.warning(f"⚠️  Loop output[{i}]: Expected object/dict, got {actual_type}")
+                        if verbose:
+                            print(f"⚠️  Loop output[{i}]: Expected 'object', received '{actual_type}'")
+                    elif expected_schema_type == 'array' and not isinstance(o, list):
+                        logger.warning(f"⚠️  Loop output[{i}]: Expected array/list, got {actual_type}")
+                        if verbose:
+                            print(f"⚠️  Loop output[{i}]: Expected 'array', received '{actual_type}'")
+        
         # Debug logging for output_variable
         if verbose:
             print(f"📦 Loop stored {len(outputs)} results in variable: '{output_var_name}'")

src/praisonai-agents/praisonaiagents/workflows/yaml_parser.py

@@ -294,6 +294,23 @@ def _parse_workflow_data(self, data: Dict[str, Any]) -> Workflow:
         # Build memory config if specified - pass raw dict for flexibility
         memory_value = memory_config if memory_config else None
 
+        # Parse context management config (CRITICAL for token overflow prevention)
+        # Supports: context: true OR context: {auto_compact: true, strategy: smart, ...}
+        context_config = data.get('context')
+        if context_config is True:
+            # Simple enable: context: true
+            context_value = True
+        elif isinstance(context_config, dict):
+            # Detailed config: context: {auto_compact: true, ...}
+            try:
+                from ..context.models import ContextConfig
+                context_value = ContextConfig(**context_config)
+            except Exception:
+                # Fallback: just enable with True if ContextConfig fails
+                context_value = True
+        else:
+            context_value = None
+        
         workflow = Workflow(
             name=name,
             steps=steps,
@@ -302,6 +319,7 @@ def _parse_workflow_data(self, data: Dict[str, Any]) -> Workflow:
             default_llm=default_llm,
             output=workflow_output,  # Pass output mode to Workflow
             memory=memory_value,  # Pass memory config to Workflow
+            context=context_value,  # Pass context management config to Workflow
         )
 
         # Store additional attributes for feature parity with agents.yaml

src/praisonai-agents/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.12.18"
+version = "0.12.20"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 readme = "README.md"
 requires-python = ">=3.10"

src/praisonai-agents/uv.lock

@@ -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/v3.9.34.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v3.9.34.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v3.9.35.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v3.9.35.tar.gz | shasum -a 256`.split.first
     license "MIT"
 
     depends_on "python@3.11"