Release v2.3.19

README.md

@@ -108,6 +108,10 @@ PraisonAI is a production-ready Multi-AI Agents framework with self-reflection,
 | 🔁 Workflow Loops | [Example](examples/python/workflows/workflow_loops.py) | [📖](https://docs.praison.ai/features/workflows) |
 | 📞 Task Callbacks | [Example](examples/python/workflows/task_callbacks.py) | [📖](https://docs.praison.ai/features/workflows) |
 | 🛑 Workflow Early Stop | [Example](examples/python/workflows/workflow_early_stop.py) | [📖](https://docs.praison.ai/features/workflows) |
+| ⚡ Simple Workflow | [Example](examples/python/workflows/simple_workflow.py) | [📖](https://docs.praison.ai/features/workflows) |
+| 🤖 Workflow with Agents | [Example](examples/python/workflows/workflow_with_agents.py) | [📖](https://docs.praison.ai/features/workflows) |
+| 🔄 Conditional Steps | [Example](examples/python/workflows/workflow_conditional.py) | [📖](https://docs.praison.ai/features/workflows) |
+| 🎭 Mixed Steps | [Example](examples/python/workflows/workflow_mixed_steps.py) | [📖](https://docs.praison.ai/features/workflows) |
 
 ## Supported Providers
 
@@ -452,10 +456,38 @@ result = asyncio.run(manager.aexecute("deploy", default_llm="gpt-4o-mini"))
 - **Branching**: Use `next_steps` and `branch_condition` for conditional routing
 - **Loops**: Use `loop_over` and `loop_var` to iterate over data
 
+### Simple Workflow (Recommended)
+
+The easiest way to create workflows - just pass functions as steps:
+
+```python
+from praisonaiagents import Workflow, WorkflowContext, StepResult
+
+# Define simple handler functions
+def validate(ctx: WorkflowContext) -> StepResult:
+    if not ctx.input:
+        return StepResult(output="No input", stop_workflow=True)
+    return StepResult(output=f"Valid: {ctx.input}")
+
+def process(ctx: WorkflowContext) -> StepResult:
+    return StepResult(output=f"Processed: {ctx.previous_result}")
+
+# Create and run workflow
+workflow = Workflow(steps=[validate, process])
+result = workflow.start("Hello World", verbose=True)
+print(result["output"])  # "Processed: Valid: Hello World"
+```
+
+**Key Features:**
+- **Just pass functions** - No complex configuration needed
+- **Early stop** - Return `stop_workflow=True` to stop the workflow
+- **Context passing** - Access `ctx.input`, `ctx.previous_result`, `ctx.variables`
+- **Verbose mode** - See step-by-step progress
+
 ### Workflow Branching & Loops
 
 ```python
-from praisonaiagents.memory.workflows import WorkflowStep
+from praisonaiagents import WorkflowStep
 
 # Branching step
 decision_step = WorkflowStep(

docker/Dockerfile

@@ -16,7 +16,7 @@ RUN mkdir -p /root/.praison
 # Install Python packages (using latest versions)
 RUN pip install --no-cache-dir \
     flask \
-    "praisonai>=2.3.18" \
+    "praisonai>=2.3.19" \
     "praisonai[api]" \
     gunicorn \
     markdown

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

examples/cookbooks/Finance_Market_Job_Agents/Ai_Job_Hunting_Assistant.ipynb

@@ -29,7 +29,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/"
@@ -71,7 +71,6 @@
     "import pandas as pd\n",
     "\n",
     "print(\"📦 Dependencies installed!\")\n",
-    "print(\"🔄 Converting from AGNO → PraisonAI\")\n",
     "print(\"🎯 Building Job Hunting Agent System\")"
    ]
   },

examples/python/workflows/simple_workflow.py

@@ -0,0 +1,36 @@
+"""
+Simple Workflow Example
+
+The easiest way to create and run workflows in PraisonAI.
+Just pass functions or agents as steps - no complex configuration needed!
+"""
+
+from praisonaiagents import Workflow, WorkflowContext, StepResult
+
+# Define simple handler functions
+def validate(ctx: WorkflowContext) -> StepResult:
+    """Validate the input data."""
+    if not ctx.input:
+        return StepResult(output="No input provided", stop_workflow=True)
+    return StepResult(output=f"Validated: {ctx.input}")
+
+def process(ctx: WorkflowContext) -> StepResult:
+    """Process the validated data."""
+    return StepResult(output=f"Processed: {ctx.previous_result}")
+
+def format_output(ctx: WorkflowContext) -> StepResult:
+    """Format the final output."""
+    return StepResult(output=f"✅ Final: {ctx.previous_result}")
+
+# Create workflow - just list your functions!
+workflow = Workflow(
+    name="Simple Pipeline",
+    steps=[validate, process, format_output]
+)
+
+if __name__ == "__main__":
+    # Run the workflow - PraisonAI style uses .start()
+    result = workflow.start("Hello, World!", verbose=True)
+    
+    print(f"\nFinal output: {result['output']}")
+    print(f"Steps completed: {len(result['steps'])}")

examples/python/workflows/workflow_conditional.py

@@ -0,0 +1,68 @@
+"""
+Workflow Conditional Execution Example
+
+Demonstrates using should_run to conditionally execute steps
+based on input or previous results.
+"""
+
+from praisonaiagents import Workflow, WorkflowStep, WorkflowContext, StepResult
+
+# Condition functions - return True to run the step, False to skip
+def is_sensitive_content(ctx: WorkflowContext) -> bool:
+    """Only run compliance check for sensitive topics."""
+    sensitive_keywords = ["legal", "medical", "financial", "security"]
+    return any(keyword in ctx.input.lower() for keyword in sensitive_keywords)
+
+def needs_translation(ctx: WorkflowContext) -> bool:
+    """Only translate if content is not in English."""
+    return ctx.variables.get("language", "en") != "en"
+
+# Handler functions
+def process_content(ctx: WorkflowContext) -> StepResult:
+    return StepResult(output=f"Processed: {ctx.input}")
+
+def compliance_check(ctx: WorkflowContext) -> StepResult:
+    return StepResult(output=f"✅ Compliance verified for: {ctx.previous_result}")
+
+def translate(ctx: WorkflowContext) -> StepResult:
+    lang = ctx.variables.get("language", "unknown")
+    return StepResult(output=f"🌐 Translated to {lang}: {ctx.previous_result}")
+
+def finalize(ctx: WorkflowContext) -> StepResult:
+    return StepResult(output=f"📄 Final: {ctx.previous_result}")
+
+# Create workflow with conditional steps
+workflow = Workflow(
+    name="Conditional Pipeline",
+    steps=[
+        WorkflowStep(name="process", handler=process_content),
+        WorkflowStep(
+            name="compliance",
+            handler=compliance_check,
+            should_run=is_sensitive_content  # Only runs for sensitive content
+        ),
+        WorkflowStep(
+            name="translate",
+            handler=translate,
+            should_run=needs_translation  # Only runs if language != "en"
+        ),
+        WorkflowStep(name="finalize", handler=finalize)
+    ]
+)
+
+if __name__ == "__main__":
+    # Test 1: Normal content (skips compliance)
+    print("=== Test 1: Normal content ===")
+    result = workflow.start("Hello world", verbose=True)
+    print(f"Output: {result['output']}\n")
+    
+    # Test 2: Sensitive content (runs compliance)
+    print("=== Test 2: Legal content ===")
+    result = workflow.start("Review this legal document", verbose=True)
+    print(f"Output: {result['output']}\n")
+    
+    # Test 3: Non-English content (runs translation)
+    print("=== Test 3: Non-English content ===")
+    workflow.variables = {"language": "es"}
+    result = workflow.start("Hola mundo", verbose=True)
+    print(f"Output: {result['output']}")

examples/python/workflows/workflow_mixed_steps.py

@@ -0,0 +1,68 @@
+"""
+Mixed Steps Workflow Example
+
+Demonstrates combining different step types in a single workflow:
+- Agent instances
+- Handler functions
+- WorkflowStep with action strings
+"""
+
+from praisonaiagents import Workflow, WorkflowStep, WorkflowContext, StepResult, Agent
+
+# Create an agent
+analyzer = Agent(
+    name="Analyzer",
+    role="Data Analyst",
+    goal="Analyze and summarize data",
+    llm="gpt-4o-mini"
+)
+
+# Custom handler functions
+def validate_input(ctx: WorkflowContext) -> StepResult:
+    """Validate the input before processing."""
+    if len(ctx.input) < 5:
+        return StepResult(
+            output="Input too short. Minimum 5 characters required.",
+            stop_workflow=True
+        )
+    return StepResult(output=f"✅ Valid input: {ctx.input}")
+
+def format_output(ctx: WorkflowContext) -> StepResult:
+    """Format the final output."""
+    return StepResult(
+        output=f"📊 Report:\n{ctx.previous_result}",
+        variables={"report_generated": True}
+    )
+
+# Create workflow with mixed step types
+workflow = Workflow(
+    name="Mixed Pipeline",
+    steps=[
+        # Step 1: Function - validates input
+        validate_input,
+        
+        # Step 2: Agent - analyzes content
+        analyzer,
+        
+        # Step 3: WorkflowStep with action string
+        WorkflowStep(
+            name="enhance",
+            action="Add a conclusion to this analysis: {{previous_output}}"
+        ),
+        
+        # Step 4: Function - formats output
+        format_output
+    ],
+    default_llm="gpt-4o-mini"  # Used for action-based steps
+)
+
+if __name__ == "__main__":
+    # Test with valid input
+    print("=== Running mixed workflow ===")
+    result = workflow.start(
+        "Analyze the trends in AI adoption for 2024",
+        verbose=True
+    )
+    
+    print(f"\nFinal output:\n{result['output']}")
+    print(f"\nVariables: {result['variables']}")

examples/python/workflows/workflow_with_agents.py

@@ -0,0 +1,45 @@
+"""
+Workflow with Agents Example
+
+Demonstrates using Agent instances directly as workflow steps.
+Agents are automatically wrapped and executed in sequence.
+"""
+
+from praisonaiagents import Workflow, Agent
+
+# Create agents
+researcher = Agent(
+    name="Researcher",
+    role="Research Specialist",
+    goal="Find accurate information",
+    llm="gpt-4o-mini"
+)
+
+writer = Agent(
+    name="Writer", 
+    role="Content Writer",
+    goal="Write engaging content",
+    llm="gpt-4o-mini"
+)
+
+editor = Agent(
+    name="Editor",
+    role="Content Editor", 
+    goal="Polish and improve content",
+    llm="gpt-4o-mini"
+)
+
+# Create workflow with agents as steps
+workflow = Workflow(
+    name="Content Pipeline",
+    steps=[researcher, writer, editor]
+)
+
+if __name__ == "__main__":
+    # Run the workflow
+    result = workflow.start(
+        "Write a short paragraph about artificial intelligence",
+        verbose=True
+    )
+    
+    print(f"\nFinal output:\n{result['output']}")

src/praisonai-agents/praisonaiagents/__init__.py

@@ -54,6 +54,7 @@ except ImportError:
     MCP = None
 from .session import Session
 from .memory.memory import Memory
+from .memory.workflows import Workflow, WorkflowStep, WorkflowContext, StepResult
 from .guardrails import GuardrailResult, LLMGuardrail
 
 # Fast Context support (lazy loaded to avoid performance impact)

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

@@ -114,9 +114,9 @@ class WorkflowStep:
 @dataclass
 class Workflow:
     """A complete workflow with multiple steps."""
-    name: str
+    name: str = "Workflow"
     description: str = ""
-    steps: List[WorkflowStep] = field(default_factory=list)
+    steps: List = field(default_factory=list)  # Can be WorkflowStep, Agent, or function
     variables: Dict[str, Any] = field(default_factory=dict)
     file_path: Optional[str] = None
     
@@ -140,6 +140,175 @@ class Workflow:
             "planning": self.planning,
             "planning_llm": self.planning_llm
         }
+    
+    def run(
+        self,
+        input: str = "",
+        llm: Optional[str] = None,
+        verbose: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Run the workflow with the given input.
+        
+        This is the simplest way to execute a workflow:
+        
+        ```python
+        from praisonaiagents import Workflow, Agent
+        
+        workflow = Workflow(
+            steps=[
+                Agent(name="Writer", role="Write content"),
+                my_validator_function,
+                Agent(name="Editor", role="Edit content"),
+            ]
+        )
+        result = workflow.run("Write about AI")
+        ```
+        
+        Args:
+            input: The input text/prompt for the workflow
+            llm: LLM model to use (default: gpt-4o-mini)
+            verbose: Print step outputs
+            
+        Returns:
+            Dict with 'output' (final result) and 'steps' (all step results)
+        """
+        # Normalize steps - convert Agents/functions to WorkflowStep
+        normalized_steps = self._normalize_steps()
+        
+        # Use default LLM if not specified
+        model = llm or self.default_llm or "gpt-4o-mini"
+        
+        # Add input to variables
+        all_variables = {**self.variables, "input": input}
+        
+        results = []
+        previous_output = None
+        
+        for i, step in enumerate(normalized_steps):
+            # Create context for handlers
+            context = WorkflowContext(
+                input=input,
+                previous_result=str(previous_output) if previous_output else None,
+                current_step=step.name,
+                variables=all_variables.copy()
+            )
+            
+            # Check should_run condition
+            if step.should_run:
+                try:
+                    if not step.should_run(context):
+                        if verbose:
+                            print(f"⏭️ Skipped: {step.name}")
+                        continue
+                except Exception as e:
+                    logger.error(f"should_run failed for {step.name}: {e}")
+            
+            # Execute step
+            output = None
+            stop = False
+            
+            if step.handler:
+                # Custom handler function
+                try:
+                    result = step.handler(context)
+                    if isinstance(result, StepResult):
+                        output = result.output
+                        stop = result.stop_workflow
+                        if result.variables:
+                            all_variables.update(result.variables)
+                    else:
+                        output = str(result)
+                except Exception as e:
+                    output = f"Error: {e}"
+                    
+            elif step.agent:
+                # Direct agent
+                try:
+                    output = step.agent.chat(step.action or input)
+                except Exception as e:
+                    output = f"Error: {e}"
+                    
+            elif step.action:
+                # Action with agent_config - create temporary agent
+                try:
+                    from ..agent.agent import Agent
+                    config = step.agent_config or self.default_agent_config or {}
+                    temp_agent = Agent(
+                        name=config.get("name", step.name),
+                        role=config.get("role", "Assistant"),
+                        goal=config.get("goal", "Complete the task"),
+                        llm=config.get("llm", model),
+                        verbose=verbose
+                    )
+                    # Substitute variables in action
+                    action = step.action
+                    for key, value in all_variables.items():
+                        action = action.replace(f"{{{{{key}}}}}", str(value))
+                    if previous_output:
+                        action = action.replace("{{previous_output}}", str(previous_output))
+                    output = temp_agent.chat(action)
+                except Exception as e:
+                    output = f"Error: {e}"
+            
+            # Store result
+            results.append({
+                "step": step.name,
+                "output": output
+            })
+            previous_output = output
+            
+            if verbose:
+                print(f"✅ {step.name}: {str(output)[:100]}...")
+            
+            # Handle early stop
+            if stop:
+                if verbose:
+                    print(f"🛑 Workflow stopped at: {step.name}")
+                break
+            
+            # Store output in variables
+            var_name = step.output_variable or f"{step.name}_output"
+            all_variables[var_name] = output
+        
+        return {
+            "output": previous_output,
+            "steps": results,
+            "variables": all_variables
+        }
+    
+    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)
+                ))
+        
+        return normalized
+    
+    def start(self, input: str = "", **kwargs) -> Dict[str, Any]:
+        """Alias for run() for consistency with PraisonAIAgents."""
+        return self.run(input, **kwargs)
 
 
 class WorkflowManager:
@@ -769,7 +938,7 @@ class WorkflowManager:
                 "error": step_result.get("error")
             })
             
-            # Handle early stop (like Agno's StepOutput.stop=True)
+            # Handle early stop 
             if step_result.get("stop"):
                 self._log(f"Workflow stopped early at step '{step.name}'")
                 break

src/praisonai-agents/pyproject.toml

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

src/praisonai-agents/uv.lock

@@ -2422,7 +2422,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.196"
+version = "0.0.197"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

src/praisonai/README.md

@@ -108,6 +108,10 @@ PraisonAI is a production-ready Multi-AI Agents framework with self-reflection,
 | 🔁 Workflow Loops | [Example](examples/python/workflows/workflow_loops.py) | [📖](https://docs.praison.ai/features/workflows) |
 | 📞 Task Callbacks | [Example](examples/python/workflows/task_callbacks.py) | [📖](https://docs.praison.ai/features/workflows) |
 | 🛑 Workflow Early Stop | [Example](examples/python/workflows/workflow_early_stop.py) | [📖](https://docs.praison.ai/features/workflows) |
+| ⚡ Simple Workflow | [Example](examples/python/workflows/simple_workflow.py) | [📖](https://docs.praison.ai/features/workflows) |
+| 🤖 Workflow with Agents | [Example](examples/python/workflows/workflow_with_agents.py) | [📖](https://docs.praison.ai/features/workflows) |
+| 🔄 Conditional Steps | [Example](examples/python/workflows/workflow_conditional.py) | [📖](https://docs.praison.ai/features/workflows) |
+| 🎭 Mixed Steps | [Example](examples/python/workflows/workflow_mixed_steps.py) | [📖](https://docs.praison.ai/features/workflows) |
 
 ## Supported Providers
 
@@ -452,10 +456,38 @@ result = asyncio.run(manager.aexecute("deploy", default_llm="gpt-4o-mini"))
 - **Branching**: Use `next_steps` and `branch_condition` for conditional routing
 - **Loops**: Use `loop_over` and `loop_var` to iterate over data
 
+### Simple Workflow (Recommended)
+
+The easiest way to create workflows - just pass functions as steps:
+
+```python
+from praisonaiagents import Workflow, WorkflowContext, StepResult
+
+# Define simple handler functions
+def validate(ctx: WorkflowContext) -> StepResult:
+    if not ctx.input:
+        return StepResult(output="No input", stop_workflow=True)
+    return StepResult(output=f"Valid: {ctx.input}")
+
+def process(ctx: WorkflowContext) -> StepResult:
+    return StepResult(output=f"Processed: {ctx.previous_result}")
+
+# Create and run workflow
+workflow = Workflow(steps=[validate, process])
+result = workflow.start("Hello World", verbose=True)
+print(result["output"])  # "Processed: Valid: Hello World"
+```
+
+**Key Features:**
+- **Just pass functions** - No complex configuration needed
+- **Early stop** - Return `stop_workflow=True` to stop the workflow
+- **Context passing** - Access `ctx.input`, `ctx.previous_result`, `ctx.variables`
+- **Verbose mode** - See step-by-step progress
+
 ### Workflow Branching & Loops
 
 ```python
-from praisonaiagents.memory.workflows import WorkflowStep
+from praisonaiagents import WorkflowStep
 
 # Branching step
 decision_step = WorkflowStep(

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/v2.3.18.tar.gz"
-    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.18.tar.gz | shasum -a 256`.split.first
+    url "https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.19.tar.gz"
+    sha256 `curl -sL https://github.com/MervinPraison/PraisonAI/archive/refs/tags/v2.3.19.tar.gz | shasum -a 256`.split.first
     license "MIT"
   
     depends_on "[email protected]"

src/praisonai/praisonai/deploy.py

@@ -57,7 +57,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==2.3.18 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.3.19 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

src/praisonai/praisonai/version.py

@@ -1 +1 @@
-__version__ = "2.3.18"
+__version__ = "2.3.19"

src/praisonai/pyproject.toml

@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.7",
     "markdown>=3.5",
     "pyparsing>=3.0.0",
-    "praisonaiagents>=0.0.196",
+    "praisonaiagents>=0.0.197",
     "python-dotenv>=0.19.0",
     "instructor>=1.3.3",
     "PyYAML>=6.0",

src/praisonai/uv.lock

@@ -4197,7 +4197,7 @@ requires-dist = [
     { name = "praisonai-tools", marker = "extra == 'autogen'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'autogen-v4'", specifier = ">=0.0.22" },
     { name = "praisonai-tools", marker = "extra == 'crewai'", specifier = ">=0.0.22" },
-    { name = "praisonaiagents", specifier = ">=0.0.196" },
+    { name = "praisonaiagents", specifier = ">=0.0.197" },
     { name = "pyautogen", marker = "extra == 'autogen'", specifier = "==0.2.29" },
     { name = "pydantic", marker = "extra == 'chat'", specifier = "<=2.10.1" },
     { name = "pydantic", marker = "extra == 'code'", specifier = "<=2.10.1" },
@@ -4252,7 +4252,7 @@ wheels = [
 
 [[package]]
 name = "praisonaiagents"
-version = "0.0.196"
+version = "0.0.197"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -4261,9 +4261,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c4/ab/35494082a1d43578b71dcd288d1199f8faee2a5c74c513140065802a535b/praisonaiagents-0.0.196.tar.gz", hash = "sha256:3996cd045af3bcf883a2215ddef8ea77653aae943197917b122ba89779e0f4ca", size = 519286, upload-time = "2025-12-16T23:18:20.613Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c6/00/342eae9c9b8bc25e812ad761ad91c0ad18adc533eaa2aa3c7c31a85cd7f8/praisonaiagents-0.0.197.tar.gz", hash = "sha256:9504dcfc861907201a10335ea7b74bfe2c6d189cc4f97951b782cd6ac46c8ee0", size = 520740, upload-time = "2025-12-16T23:26:31.078Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/ec/fadfa767224f31c867826c3837764179b713bc05a612d6b9c3b82fc83286/praisonaiagents-0.0.196-py3-none-any.whl", hash = "sha256:1cb5786fc28062488162abb7f89b91f3c012aabea8c3d9baeeaf9a0799e4f814", size = 495801, upload-time = "2025-12-16T23:18:19.035Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/5d/2aaa57e97d84b12dc75b66e083839eb3f9d3ef8d7721a9d8e4e7d2513ded/praisonaiagents-0.0.197-py3-none-any.whl", hash = "sha256:701b60a02d9e7147909a1311572e092846ef8247b7251b67b31dbcd581eec1d7", size = 497086, upload-time = "2025-12-16T23:26:29.208Z" },
 ]
 
 [[package]]