PraisonAI 2.0.23__cp312-cp312-manylinux_2_39_x86_64.whl → 2.0.25__cp312-cp312-manylinux_2_39_x86_64.whl

praisonai/deploy.py

@@ -56,7 +56,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.0.23 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.0.25 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

praisonai/ui/agents.py

@@ -5,7 +5,7 @@ import chainlit as cl
 import os
 from chainlit.types import ThreadDict
 from chainlit.input_widget import Select, TextInput
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, AsyncGenerator, List, Callable
 from dotenv import load_dotenv
 from datetime import datetime
 import json
@@ -18,6 +18,9 @@ from contextlib import redirect_stdout, asynccontextmanager
 from db import DatabaseManager
 import time
 import sqlite3
+from openai import AsyncOpenAI
+from functools import partial
+import yaml
 
 # Load environment variables
 load_dotenv()
@@ -354,37 +357,193 @@ async def on_chat_resume(thread: ThreadDict):
 # async def tool(data: Optional[str] = None, language: Optional[str] = None):
 #     return cl.Message(content=data, language=language)
 
+# Add callback handler class
+class ChainlitCallbackHandler:
+    """Callback handler for streaming agent execution to Chainlit"""
+    
+    def __init__(self, parent_step: Optional[cl.Step] = None):
+        self.parent_step = parent_step
+        self.current_step = None
+        self._steps = {}
+    
+    async def on_agent_start(self, agent_name: str):
+        """Called when an agent starts execution"""
+        self.current_step = cl.Step(
+            name=f"Agent: {agent_name}",
+            type="agent",
+            show_input=True,
+            parent_id=self.parent_step.id if self.parent_step else None
+        )
+        await self.current_step.start()
+        await self.current_step.stream_token(f"🤖 Agent {agent_name} started\n")
+        self._steps[agent_name] = self.current_step
+
+    async def on_agent_action(self, agent_name: str, action: str):
+        """Called when an agent performs an action"""
+        step = self._steps.get(agent_name, self.current_step)
+        if step:
+            await step.stream_token(f"⚡ {action}\n")
+
+    async def on_agent_finish(self, agent_name: str, output: Any):
+        """Called when an agent finishes execution"""
+        step = self._steps.get(agent_name)
+        if step:
+            await step.stream_token(f"\n✅ Agent {agent_name} finished\n")
+            step.output = str(output)
+            await step.end()
+            self._steps.pop(agent_name, None)
+
+    async def on_task_start(self, task_id: str, task_name: str):
+        """Called when a task starts execution"""
+        self.current_step = cl.Step(
+            name=f"Task: {task_name}",
+            type="task",
+            show_input=True,
+            parent_id=self.parent_step.id if self.parent_step else None
+        )
+        await self.current_step.start()
+        await self.current_step.stream_token(f"📋 Starting task: {task_name}\n")
+        self._steps[task_id] = self.current_step
+
+    async def on_task_finish(self, task_id: str, output: Any):
+        """Called when a task finishes execution"""
+        step = self._steps.get(task_id, self.current_step)
+        if step:
+            await step.stream_token(f"\n✅ Task completed\n")
+            step.output = str(output)
+            await step.end()
+            self._steps.pop(task_id, None)
+
+    async def on_error(self, error: str):
+        """Called when an error occurs"""
+        if self.current_step:
+            await self.current_step.stream_token(f"\n❌ Error: {error}\n")
+            await self.current_step.end()
+
 @cl.step(type="tool", show_input=False)
 async def run_agents(agent_file: str, framework: str):
     """Runs the agents and returns the result."""
     try:
         logger.debug(f"Running agents with file: {agent_file}, framework: {framework}")
-        agents_generator = AgentsGenerator(agent_file, framework, config_list)
-        current_step = cl.context.current_step
-        logger.debug(f"Current Step: {current_step}")
-
-        stdout_buffer = StringIO()
-        with redirect_stdout(stdout_buffer):
-            result = agents_generator.generate_crew_and_kickoff()
+        
+        # Create main execution step
+        async with cl.Step(name="Agents Execution", type="agents") as agents_step:
+            agents_step.input = f"Running agents from {agent_file}"
             
-        complete_output = stdout_buffer.getvalue()
-        logger.debug(f"Agent execution output: {complete_output}")
-
-        async with cl.Step(name="gpt4", type="llm", show_input=True) as step:
-            step.input = ""
+            # Initialize callback handler
+            callback_handler = ChainlitCallbackHandler(parent_step=agents_step)
             
-            for line in stdout_buffer.getvalue().splitlines():
-                logger.debug(f"Agent output line: {line}")
-                await step.stream_token(line)
+            try:
+                # Load YAML config first
+                with open(agent_file, 'r') as f:
+                    config = yaml.safe_load(f)
+                
+                # Get topic from message content
+                topic = cl.user_session.get("message_history", [{}])[-1].get("content", "")
+                
+                # Create agents generator with loaded config
+                agents_generator = AgentsGenerator(
+                    agent_file=agent_file,
+                    framework=framework,
+                    config_list=config_list,
+                    agent_yaml=yaml.dump(config)  # Pass the loaded config as YAML string
+                )
+                
+                # Execute based on framework
+                if framework == "crewai":
+                    result = agents_generator._run_crewai(config, topic, [])
+                elif framework == "autogen":
+                    result = agents_generator._run_autogen(config, topic, [])
+                elif framework == "praisonai":
+                    result = agents_generator._run_praisonai(config, topic, [])
+                else:
+                    raise ValueError(f"Unsupported framework: {framework}")
+                
+                # Process the result if it has tasks
+                if hasattr(result, 'tasks') and result.tasks:
+                    for task in result.tasks:
+                        task_id = getattr(task, 'id', str(id(task)))
+                        task_desc = getattr(task, 'description', 'Executing task...')
+                        
+                        # Signal task start
+                        await callback_handler.on_task_start(
+                            task_id,
+                            task_desc[:50] + "..." if len(task_desc) > 50 else task_desc
+                        )
+                        
+                        try:
+                            # Handle agent actions if present
+                            agent = getattr(task, 'agent', None)
+                            if agent:
+                                agent_name = getattr(agent, 'name', 'Unknown Agent')
+                                await callback_handler.on_agent_start(agent_name)
+                                await callback_handler.on_agent_action(
+                                    agent_name,
+                                    f"Working on task: {task_desc[:50]}..."
+                                )
+                            
+                            # Get task output
+                            task_output = getattr(task, 'output', str(task))
+                            
+                            # Signal agent completion if exists
+                            if agent:
+                                await callback_handler.on_agent_finish(agent_name, task_output)
+                            
+                            # Signal task completion
+                            await callback_handler.on_task_finish(task_id, task_output)
+                            
+                        except Exception as e:
+                            await callback_handler.on_error(f"Error in task {task_id}: {str(e)}")
+                            raise
                 
-            tool_res = await output(complete_output)
+                # Return the final result
+                agents_step.output = "Agents execution completed"
+                return result if isinstance(result, str) else str(result)
+                
+            except Exception as e:
+                await callback_handler.on_error(str(e))
+                raise
 
-        return result
     except Exception as e:
         error_msg = f"Error running agents: {str(e)}"
         logger.error(error_msg)
         raise Exception(error_msg)
 
+async def stream_agents_execution(agents) -> AsyncGenerator[tuple[str, str, str], None]:
+    """
+    Generator to stream agents execution status and messages.
+    Yields tuples of (task_id, status, message)
+    """
+    try:
+        for task_id in agents.tasks:
+            task = agents.tasks[task_id]
+            
+            # Signal task start
+            yield task_id, "start", ""
+            
+            if task.async_execution:
+                # Execute async task
+                result = await agents.aexecute_task(task_id)
+            else:
+                # Execute sync task in thread pool
+                result = await cl.make_async(agents.execute_task)(task_id)
+            
+            if result:
+                # Stream agent messages
+                if isinstance(result, str):
+                    yield task_id, "agent_message", result
+                else:
+                    yield task_id, "agent_message", result.raw
+                
+                # Signal completion
+                yield task_id, "complete", ""
+            else:
+                yield task_id, "error", "Task execution failed"
+                
+    except Exception as e:
+        logger.error(f"Error in stream_agents_execution: {e}")
+        yield task_id, "error", str(e)
+
 @cl.step(type="tool", show_input=False, language="yaml")
 async def output(output):
     return output
@@ -405,17 +564,38 @@ def task(output):
         {output}
     """)
 
+# Add retry decorator for database operations
+def with_retries(max_retries=3, delay=1):
+    def decorator(func):
+        async def wrapper(*args, **kwargs):
+            for attempt in range(max_retries):
+                try:
+                    return await func(*args, **kwargs)
+                except sqlite3.OperationalError as e:
+                    if "database is locked" in str(e) and attempt < max_retries - 1:
+                        await asyncio.sleep(delay)
+                        continue
+                    raise
+            return await func(*args, **kwargs)
+        return wrapper
+    return decorator
+
+@with_retries(max_retries=3, delay=1)
+async def update_thread_metadata(thread_id: str, metadata: dict):
+    """Update thread metadata with retry logic"""
+    await cl_data.update_thread(thread_id, metadata=metadata)
+
 @cl.on_message
 async def main(message: cl.Message):
-    """Run PraisonAI with the provided message as the topic."""
     try:
-        # Get or initialize message history
-        message_history = cl.user_session.get("message_history")
-        if message_history is None:
-            message_history = []
-            cl.user_session.set("message_history", message_history)
+        # Get settings and chat profile
+        settings = cl.user_session.get("settings")
+        chat_profile = cl.user_session.get("chat_profile")
         
-        # Add current message to history
+        # Get message history or initialize if not exists
+        message_history = cl.user_session.get("message_history", [])
+        
+        # Format user message with context
         now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         user_message = f"""
         Answer the question and use tools if needed:
@@ -424,54 +604,27 @@ async def main(message: cl.Message):
 
         User Question: {message.content}
         """
+        
+        # Add to message history
         message_history.append({"role": "user", "content": user_message})
         
-        # Get chat profile and process accordingly
+        # Get configuration
+        framework = settings["Framework"]
         topic = message.content
-        chat_profile = cl.user_session.get("chat_profile")
-        logger.debug(f"Processing message with chat profile: {chat_profile}")
 
         if chat_profile == "Auto":
             agent_file = "agents.yaml"
             logger.info(f"Generating agents for topic: {topic}")
             generator = AutoGenerator(topic=topic, agent_file=agent_file, framework=framework, config_list=config_list)
+            
             await cl.sleep(2)
             agent_file = generator.generate()
             
-            logger.debug("Starting agents execution")
-            agents_generator = AgentsGenerator(
-                agent_file, 
-                framework, 
-                config_list
-            )
+            # Run agents with streaming while preserving context
+            result = await run_agents(agent_file, framework)
+            await cl.Message(content=result).send()
             
-            # Capture stdout
-            stdout_buffer = StringIO()
-            with redirect_stdout(stdout_buffer):
-                result = agents_generator.generate_crew_and_kickoff()
-                
-            complete_output = stdout_buffer.getvalue()
-            logger.debug(f"Agents execution output: {complete_output}")
-            
-            tool_res = await output(complete_output)
-            msg = cl.Message(content=result)
-            await msg.send()
-            
-            # Save to message history
-            message_history.append({"role": "assistant", "content": result})
-            cl.user_session.set("message_history", message_history)
-            
-            # Update thread metadata if exists
-            thread_id = cl.user_session.get("thread_id")
-            if thread_id:
-                metadata = {
-                    "last_response": result,
-                    "timestamp": now,
-                    "mode": "auto"
-                }
-                await cl_data.update_thread(thread_id, metadata=metadata)
-                
-        else:  # chat_profile == "Manual"
+        else:  # Manual mode
             agent_file = "agents.yaml"
             full_agent_file_path = os.path.abspath(agent_file)
             full_tools_file_path = os.path.abspath("tools.py")
@@ -487,31 +640,25 @@ async def main(message: cl.Message):
                         tools_content = f.read()
                     msg_tools = cl.Message(content=tools_content, language="python")
                     await msg_tools.send()
-            else:
-                logger.info("Generating agents for manual mode")
-                generator = AutoGenerator(topic=topic, agent_file=agent_file, framework=framework, config_list=config_list)
-                agent_file = generator.generate()
-
-            logger.debug("Starting agents execution for manual mode")
-            agents_generator = AgentsGenerator(agent_file, framework, config_list)
-            result = agents_generator.generate_crew_and_kickoff()
-            msg = cl.Message(content=result, actions=actions)
-            await msg.send()
-            
-            # Save to message history
-            message_history.append({"role": "assistant", "content": result})
-            cl.user_session.set("message_history", message_history)
             
-            # Update thread metadata if exists
-            thread_id = cl.user_session.get("thread_id")
-            if thread_id:
-                metadata = {
-                    "last_response": result,
-                    "timestamp": now,
-                    "mode": "manual"
-                }
-                await cl_data.update_thread(thread_id, metadata=metadata)
-                
+            # Run agents with streaming while preserving context
+            result = await run_agents(agent_file, framework)
+            await cl.Message(content=result, actions=actions).send()
+
+        # Update message history
+        message_history.append({"role": "assistant", "content": result})
+        cl.user_session.set("message_history", message_history)
+        
+        # Update thread metadata with retry logic
+        thread_id = cl.user_session.get("thread_id")
+        if thread_id:
+            metadata = {
+                "last_response": result,
+                "timestamp": now,
+                "mode": chat_profile.lower()
+            }
+            await update_thread_metadata(thread_id, metadata)
+
     except Exception as e:
         error_msg = f"Error processing message: {str(e)}"
         logger.error(error_msg)

praisonai/ui/callbacks.py

@@ -0,0 +1,57 @@
+import logging
+from typing import Dict, Any, Callable, Optional, Union
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+class CallbackManager:
+    """Manages callbacks for the PraisonAI UI"""
+    
+    def __init__(self):
+        self._callbacks: Dict[str, Dict[str, Union[Callable, bool]]] = {}
+    
+    def register(self, name: str, callback: Callable, is_async: bool = False) -> None:
+        """Register a callback function"""
+        self._callbacks[name] = {
+            'func': callback,
+            'is_async': is_async
+        }
+    
+    async def call(self, name: str, **kwargs) -> None:
+        """Call a registered callback"""
+        if name not in self._callbacks:
+            logger.warning(f"No callback registered for {name}")
+            return
+            
+        callback_info = self._callbacks[name]
+        func = callback_info['func']
+        is_async = callback_info['is_async']
+        
+        try:
+            if is_async:
+                await func(**kwargs)
+            else:
+                if asyncio.iscoroutinefunction(func):
+                    await func(**kwargs)
+                else:
+                    await asyncio.get_event_loop().run_in_executor(None, lambda: func(**kwargs))
+        except Exception as e:
+            logger.error(f"Error in callback {name}: {str(e)}")
+
+# Global callback manager instance
+callback_manager = CallbackManager()
+
+def register_callback(name: str, callback: Callable, is_async: bool = False) -> None:
+    """Register a callback with the global callback manager"""
+    callback_manager.register(name, callback, is_async)
+
+async def trigger_callback(name: str, **kwargs) -> None:
+    """Trigger a callback from the global callback manager"""
+    await callback_manager.call(name, **kwargs)
+
+# Decorator for registering callbacks
+def callback(name: str, is_async: bool = False):
+    def decorator(func):
+        register_callback(name, func, is_async)
+        return func
+    return decorator 

praisonai/ui/colab.py

@@ -0,0 +1,474 @@
+from praisonaiagents import Agent, Task, PraisonAIAgents
+import os
+import importlib
+import inspect
+import yaml
+import logging
+from .callbacks import trigger_callback
+import asyncio
+import chainlit as cl
+from queue import Queue
+
+logger = logging.getLogger(__name__)
+agent_file = "agents.yaml"
+
+with open(agent_file, 'r') as f:
+    config = yaml.safe_load(f)
+
+topic = "get from the message content from the chainlit user message"
+
+# Create a message queue
+message_queue = Queue()
+
+async def process_message_queue():
+    """Process messages in the queue and send them to Chainlit"""
+    while True:
+        try:
+            if not message_queue.empty():
+                msg_data = message_queue.get()
+                await cl.Message(**msg_data).send()
+            await asyncio.sleep(0.1)  # Small delay to prevent busy waiting
+        except Exception as e:
+            logger.error(f"Error processing message queue: {e}")
+
+def load_tools_from_tools_py():
+    """
+    Imports and returns all contents from tools.py file.
+    Also adds the tools to the global namespace.
+
+    Returns:
+        list: A list of callable functions with proper formatting
+    """
+    tools_list = []
+    try:
+        # Try to import tools.py from current directory
+        spec = importlib.util.spec_from_file_location("tools", "tools.py")
+        logger.info(f"Spec: {spec}")
+        if spec is None:
+            logger.info("tools.py not found in current directory")
+            return tools_list
+
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        # Get all module attributes except private ones and classes
+        for name, obj in inspect.getmembers(module):
+            if (not name.startswith('_') and 
+                callable(obj) and 
+                not inspect.isclass(obj)):
+                # Add the function to global namespace
+                globals()[name] = obj
+                # Format the tool as an OpenAI function
+                tool = {
+                    "type": "function",
+                    "function": {
+                        "name": name,
+                        "description": obj.__doc__ or f"Function to {name.replace('_', ' ')}",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "The search query to look up information about"
+                                }
+                            },
+                            "required": ["query"]
+                        }
+                    }
+                }
+                # Add formatted tool to tools list
+                tools_list.append(tool)
+                logger.info(f"Loaded and globalized tool function: {name}")
+
+        logger.info(f"Loaded {len(tools_list)} tool functions from tools.py")
+        logger.info(f"Tools list: {tools_list}")
+        
+    except Exception as e:
+        logger.warning(f"Error loading tools from tools.py: {e}")
+        
+    return tools_list
+
+async def step_callback(step_details):
+    """Callback for agent steps"""
+    logger.info(f"[CALLBACK DEBUG] Step callback triggered with details: {step_details}")
+    try:
+        # Queue message for agent response
+        if step_details.get("response"):
+            message_queue.put({
+                "content": f"Agent Response: {step_details.get('response')}",
+                "author": step_details.get("agent_name", "Agent")
+            })
+            logger.info("[CALLBACK DEBUG] Queued agent response message")
+        
+        # Queue message for tool usage
+        if step_details.get("tool_name"):
+            message_queue.put({
+                "content": f"🛠️ Using tool: {step_details.get('tool_name')}",
+                "author": "System"
+            })
+            logger.info("[CALLBACK DEBUG] Queued tool usage message")
+            
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in step callback: {str(e)}", exc_info=True)
+
+async def task_callback(task_output):
+    """Callback for task completion"""
+    logger.info(f"[CALLBACK DEBUG] Task callback triggered with output: {task_output}")
+    try:
+        # Create message content
+        if hasattr(task_output, 'raw'):
+            content = task_output.raw
+        elif hasattr(task_output, 'content'):
+            content = task_output.content
+        else:
+            content = str(task_output)
+            
+        # Queue the message
+        message_queue.put({
+            "content": f"Task Output: {content}",
+            "author": "Task"
+        })
+        logger.info("[CALLBACK DEBUG] Queued task completion message")
+        
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in task callback: {str(e)}", exc_info=True)
+
+async def step_callback_wrapper(step_details):
+    logger.info(f"[CALLBACK DEBUG] Step callback wrapper triggered with details: {step_details}")
+    try:
+        # Check if we have a Chainlit context
+        if not cl.context.context_var.get():
+            logger.warning("[CALLBACK DEBUG] No Chainlit context available in wrapper")
+            return
+        logger.info("[CALLBACK DEBUG] Chainlit context found in wrapper")
+
+        # Create a message for the agent's response
+        if step_details.get("response"):
+            logger.info(f"[CALLBACK DEBUG] Sending agent response from wrapper: {step_details.get('response')}")
+            try:
+                await cl.Message(
+                    content=f"{role_name}: {step_details.get('response')}",
+                    author=role_name,
+                ).send()
+                logger.info("[CALLBACK DEBUG] Successfully sent agent response message from wrapper")
+            except Exception as e:
+                logger.error(f"[CALLBACK DEBUG] Error sending agent response message from wrapper: {str(e)}")
+
+        # Create a message for any tool usage
+        if step_details.get("tool_name"):
+            logger.info(f"[CALLBACK DEBUG] Sending tool usage from wrapper: {step_details.get('tool_name')}")
+            try:
+                await cl.Message(
+                    content=f"🛠️ {role_name} is using tool: {step_details.get('tool_name')}",
+                    author="System",
+                ).send()
+                logger.info("[CALLBACK DEBUG] Successfully sent tool usage message from wrapper")
+            except Exception as e:
+                logger.error(f"[CALLBACK DEBUG] Error sending tool usage message from wrapper: {str(e)}")
+
+        # Create a message for any thoughts or reasoning
+        if step_details.get("thought"):
+            logger.info(f"[CALLBACK DEBUG] Sending thought from wrapper: {step_details.get('thought')}")
+            try:
+                await cl.Message(
+                    content=f"💭 {role_name}'s thought: {step_details.get('thought')}",
+                    author=role_name,
+                ).send()
+                logger.info("[CALLBACK DEBUG] Successfully sent thought message from wrapper")
+            except Exception as e:
+                logger.error(f"[CALLBACK DEBUG] Error sending thought message from wrapper: {str(e)}")
+
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in step callback wrapper: {str(e)}", exc_info=True)
+        try:
+            await cl.Message(
+                content=f"Error in step callback: {str(e)}",
+                author="System",
+            ).send()
+        except Exception as send_error:
+            logger.error(f"[CALLBACK DEBUG] Error sending error message: {str(send_error)}")
+
+async def task_callback_wrapper(task_output):
+    logger.info(f"[CALLBACK DEBUG] Task callback wrapper triggered with output type: {type(task_output)}")
+    try:
+        # Check if we have a Chainlit context
+        if not cl.context.context_var.get():
+            logger.warning("[CALLBACK DEBUG] No Chainlit context available in task wrapper")
+            return
+        logger.info("[CALLBACK DEBUG] Chainlit context found in task wrapper")
+
+        # Create a message for task completion
+        if hasattr(task_output, 'raw'):
+            content = task_output.raw
+            logger.info("[CALLBACK DEBUG] Using raw output")
+        elif hasattr(task_output, 'content'):
+            content = task_output.content
+            logger.info("[CALLBACK DEBUG] Using content output")
+        else:
+            content = str(task_output)
+            logger.info("[CALLBACK DEBUG] Using string representation of output")
+            
+        logger.info(f"[CALLBACK DEBUG] Sending task completion message from wrapper: {content[:100]}...")
+        try:
+            await cl.Message(
+                content=f"✅ {role_name} completed task:\n{content}",
+                author=role_name,
+            ).send()
+            logger.info("[CALLBACK DEBUG] Successfully sent task completion message from wrapper")
+        except Exception as e:
+            logger.error(f"[CALLBACK DEBUG] Error sending task completion message from wrapper: {str(e)}")
+
+        # If there are any additional task details
+        if hasattr(task_output, 'details'):
+            logger.info("[CALLBACK DEBUG] Task has additional details")
+            try:
+                await cl.Message(
+                    content=f"📝 Additional details:\n{task_output.details}",
+                    author=role_name,
+                ).send()
+                logger.info("[CALLBACK DEBUG] Successfully sent additional details message")
+            except Exception as e:
+                logger.error(f"[CALLBACK DEBUG] Error sending additional details message: {str(e)}")
+
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in task callback wrapper: {str(e)}", exc_info=True)
+        try:
+            await cl.Message(
+                content=f"Error in task callback: {str(e)}",
+                author="System",
+            ).send()
+        except Exception as send_error:
+            logger.error(f"[CALLBACK DEBUG] Error sending error message: {str(send_error)}")
+
+def sync_task_callback_wrapper(task_output):
+    logger.info("[CALLBACK DEBUG] Sync task callback wrapper triggered")
+    try:
+        # Create a new event loop for this thread if there isn't one
+        try:
+            loop = asyncio.get_event_loop()
+            logger.info("[CALLBACK DEBUG] Got existing event loop")
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            logger.info("[CALLBACK DEBUG] Created new event loop")
+        
+        if loop.is_running():
+            # If loop is running, schedule the callback
+            logger.info("[CALLBACK DEBUG] Loop is running, scheduling callback")
+            asyncio.run_coroutine_threadsafe(
+                task_callback_wrapper(task_output),
+                loop
+            )
+        else:
+            # If loop is not running, run it directly
+            logger.info("[CALLBACK DEBUG] Loop is not running, running callback directly")
+            loop.run_until_complete(task_callback_wrapper(task_output))
+            
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in sync task callback: {str(e)}", exc_info=True)
+
+def sync_step_callback_wrapper(step_details):
+    logger.info("[CALLBACK DEBUG] Sync step callback wrapper triggered")
+    try:
+        # Create a new event loop for this thread if there isn't one
+        try:
+            loop = asyncio.get_event_loop()
+            logger.info("[CALLBACK DEBUG] Got existing event loop")
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            logger.info("[CALLBACK DEBUG] Created new event loop")
+        
+        if loop.is_running():
+            # If loop is running, schedule the callback
+            logger.info("[CALLBACK DEBUG] Loop is running, scheduling callback")
+            asyncio.run_coroutine_threadsafe(
+                step_callback_wrapper(step_details),
+                loop
+            )
+        else:
+            # If loop is not running, run it directly
+            logger.info("[CALLBACK DEBUG] Loop is not running, running callback directly")
+            loop.run_until_complete(step_callback_wrapper(step_details))
+            
+    except Exception as e:
+        logger.error(f"[CALLBACK DEBUG] Error in sync step callback: {str(e)}", exc_info=True)
+
+async def ui_run_praisonai(config, topic, tools_dict):
+    """Run PraisonAI with the given configuration and topic."""
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.DEBUG)
+    agents = {}
+    tasks = []
+    tasks_dict = {}
+
+    try:
+        # Start message queue processor
+        queue_processor = asyncio.create_task(process_message_queue())
+        
+        # Create agents for each role
+        for role, details in config['roles'].items():
+            # Format the role name and other details
+            role_name = details.get('name', role).format(topic=topic)
+            role_filled = details.get('role', role).format(topic=topic)
+            goal_filled = details['goal'].format(topic=topic)
+            backstory_filled = details['backstory'].format(topic=topic)
+
+            # Test message to verify Chainlit is working
+            await cl.Message(
+                content=f"[DEBUG] Creating agent: {role_name}",
+                author="System"
+            ).send()
+
+            # Create a sync wrapper for the step callback
+            def step_callback_sync(step_details):
+                try:
+                    # Create a new event loop for this thread
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    
+                    # Add agent name to step details
+                    step_details["agent_name"] = role_name
+                    
+                    # Run the callback
+                    loop.run_until_complete(step_callback(step_details))
+                    loop.close()
+                except Exception as e:
+                    logger.error(f"[CALLBACK DEBUG] Error in step callback: {str(e)}", exc_info=True)
+
+            agent = Agent(
+                name=role_name,
+                role=role_filled,
+                goal=goal_filled,
+                backstory=backstory_filled,
+                llm=details.get('llm', 'gpt-4o'),
+                verbose=True,
+                allow_delegation=details.get('allow_delegation', False),
+                max_iter=details.get('max_iter', 15),
+                max_rpm=details.get('max_rpm'),
+                max_execution_time=details.get('max_execution_time'),
+                cache=details.get('cache', True),
+                step_callback=step_callback_sync
+            )
+            agents[role] = agent
+
+        # Create tasks for each role
+        for role, details in config['roles'].items():
+            agent = agents[role]
+            tools_list = []
+            
+            # Get tools for this role
+            for tool_name in details.get('tools', []):
+                if tool_name in tools_dict:
+                    tool_func = tools_dict[tool_name]
+                    tools_list.append(tool_func)
+
+            # Create tasks for the agent
+            for task_name, task_details in details.get('tasks', {}).items():
+                description_filled = task_details['description'].format(topic=topic)
+                expected_output_filled = task_details['expected_output'].format(topic=topic)
+
+                # Test message to verify task creation
+                await cl.Message(
+                    content=f"[DEBUG] Created task: {task_name} for agent {role_name}",
+                    author="System"
+                ).send()
+
+                # Create a sync wrapper for the task callback
+                def task_callback_sync(task_output):
+                    try:
+                        # Create a new event loop for this thread
+                        loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(loop)
+                        
+                        # Run the callback
+                        loop.run_until_complete(task_callback(task_output))
+                        loop.close()
+                    except Exception as e:
+                        logger.error(f"[CALLBACK DEBUG] Error in task callback: {str(e)}", exc_info=True)
+
+                task = Task(
+                    description=description_filled,
+                    expected_output=expected_output_filled,
+                    agent=agent,
+                    tools=tools_list,
+                    async_execution=True,
+                    context=[],
+                    config=task_details.get('config', {}),
+                    output_json=task_details.get('output_json'),
+                    output_pydantic=task_details.get('output_pydantic'),
+                    output_file=task_details.get('output_file', ""),
+                    callback=task_callback_sync,
+                    create_directory=task_details.get('create_directory', False)
+                )
+
+                tasks.append(task)
+                tasks_dict[task_name] = task
+
+        # Set up task contexts
+        for role, details in config['roles'].items():
+            for task_name, task_details in details.get('tasks', {}).items():
+                task = tasks_dict[task_name]
+                context_tasks = [tasks_dict[ctx] for ctx in task_details.get('context', []) 
+                            if ctx in tasks_dict]
+                task.context = context_tasks
+
+        # Send the start message
+        await cl.Message(
+            content="Starting PraisonAI agents execution...",
+            author="System"
+        ).send()
+
+        # Create and run the PraisonAI agents
+        if config.get('process') == 'hierarchical':
+            crew = PraisonAIAgents(
+                agents=list(agents.values()),
+                tasks=tasks,
+                verbose=True,
+                process="hierarchical",
+                manager_llm=config.get('manager_llm', 'gpt-4o')
+            )
+        else:
+            crew = PraisonAIAgents(
+                agents=list(agents.values()),
+                tasks=tasks,
+                verbose=2
+            )
+
+        # Store the crew in the user session
+        cl.user_session.set("crew", crew)
+
+        # Run the agents in a separate thread
+        loop = asyncio.get_event_loop()
+        response = await loop.run_in_executor(None, crew.start)
+        
+        logger.debug(f"[CALLBACK DEBUG] Result: {response}")
+        
+        # Convert response to string if it's not already
+        if hasattr(response, 'raw'):
+            result = response.raw
+        elif hasattr(response, 'content'):
+            result = response.content
+        else:
+            result = str(response)
+        
+        # Send the completion message
+        await cl.Message(
+            content="PraisonAI agents execution completed.",
+            author="System"
+        ).send()
+        
+        # After getting the response, wait a bit for remaining messages
+        await asyncio.sleep(1)  # Give time for final messages to be processed
+        queue_processor.cancel()  # Stop the queue processor
+        
+        return result
+        
+    except Exception as e:
+        error_msg = f"Error in ui_run_praisonai: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        await cl.Message(
+            content=error_msg,
+            author="System"
+        ).send()
+        raise

praisonai/ui/colab_chainlit.py

@@ -0,0 +1,81 @@
+import os
+import logging
+from dotenv import load_dotenv
+import chainlit as cl
+from chainlit.types import ThreadDict
+import yaml
+import sys
+import os
+from datetime import datetime
+
+# Add the parent directory to sys.path to allow imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from praisonai.ui.colab import ui_run_praisonai, load_tools_from_tools_py
+from praisonai.ui.callbacks import callback, trigger_callback
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logger = logging.getLogger(__name__)
+log_level = os.getenv("LOGLEVEL", "INFO").upper()
+logger.setLevel(log_level)
+
+# Load agent configuration
+agent_file = "agents.yaml"
+with open(agent_file, 'r') as f:
+    config = yaml.safe_load(f)
+
+# Load tools
+tools_dict = load_tools_from_tools_py()
+
+@cl.on_message
+async def main(message: cl.Message):
+    """Main message handler for Chainlit"""
+    try:
+        logger.info(f"Processing message: {message.content}")
+        await cl.Message(
+            content=f"🔄 Processing your request about: {message.content}...",
+            author="System"
+        ).send()
+
+        await cl.Message(
+            content="Using Running PraisonAI Agents...",
+            author="System"
+        ).send()
+
+        # Run PraisonAI with the message content as the topic
+        result = await ui_run_praisonai(config, message.content, tools_dict)
+        
+        # Send the final result
+        await cl.Message(
+            content=result,
+            author="System"
+        ).send()
+
+    except Exception as e:
+        error_msg = f"Error running PraisonAI agents: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        await cl.Message(
+            content=error_msg,
+            author="System"
+        ).send()
+
+@cl.on_chat_start
+async def start():
+    """Handler for chat start"""
+    await cl.Message(
+        content="👋 Welcome! I'm your AI assistant. What would you like to work on?",
+        author="System"
+    ).send()
+
+# Authentication setup (optional)
+if os.getenv("CHAINLIT_AUTH_SECRET"):
+    @cl.password_auth_callback
+    def auth_callback(username: str, password: str) -> cl.User:
+        # Replace with your authentication logic
+        if username == os.getenv("CHAINLIT_USERNAME", "admin") and \
+           password == os.getenv("CHAINLIT_PASSWORD", "admin"):
+            return cl.User(identifier=username, metadata={"role": "user"})
+        return None 

praisonai/ui/config/chainlit.md

@@ -1 +1 @@
-# Welcome to Praison AI! 🚀🤖
+# Welcome to PraisonAI! 🚀

{praisonai-2.0.23.dist-info → praisonai-2.0.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: PraisonAI
-Version: 2.0.23
+Version: 2.0.25
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human–agent collaboration.
 Author: Mervin Praison
 Requires-Python: >=3.10,<3.13
@@ -21,43 +21,68 @@ Provides-Extra: google
 Provides-Extra: gradio
 Provides-Extra: openai
 Provides-Extra: realtime
-Provides-Extra: train
 Provides-Extra: ui
 Requires-Dist: PyYAML (>=6.0)
 Requires-Dist: agentops (>=0.3.12) ; extra == "agentops"
-Requires-Dist: aiosqlite (>=0.20.0) ; extra == "ui" or extra == "chat" or extra == "code" or extra == "realtime"
-Requires-Dist: chainlit (==2.0rc1) ; extra == "ui" or extra == "chat" or extra == "code" or extra == "realtime"
-Requires-Dist: crawl4ai (==0.3.4) ; extra == "chat" or extra == "code" or extra == "realtime"
-Requires-Dist: crewai (>=0.32.0) ; extra == "crewai" or extra == "autogen"
+Requires-Dist: aiosqlite (>=0.20.0) ; extra == "chat"
+Requires-Dist: aiosqlite (>=0.20.0) ; extra == "code"
+Requires-Dist: aiosqlite (>=0.20.0) ; extra == "realtime"
+Requires-Dist: aiosqlite (>=0.20.0) ; extra == "ui"
+Requires-Dist: chainlit (==1.3.2) ; extra == "chat"
+Requires-Dist: chainlit (==1.3.2) ; extra == "code"
+Requires-Dist: chainlit (==1.3.2) ; extra == "realtime"
+Requires-Dist: chainlit (==1.3.2) ; extra == "ui"
+Requires-Dist: crawl4ai (==0.3.4) ; extra == "chat"
+Requires-Dist: crawl4ai (==0.3.4) ; extra == "code"
+Requires-Dist: crawl4ai (==0.3.4) ; extra == "realtime"
+Requires-Dist: crewai (>=0.32.0) ; extra == "crewai"
+Requires-Dist: crewai ; extra == "autogen"
 Requires-Dist: duckduckgo_search (>=6.3.0) ; extra == "realtime"
 Requires-Dist: fastapi (>=0.95.0) ; extra == "call"
 Requires-Dist: flaml[automl] (>=2.3.1) ; extra == "call"
 Requires-Dist: flask (>=3.0.0) ; extra == "api"
 Requires-Dist: gradio (>=4.26.0) ; extra == "gradio"
-Requires-Dist: greenlet (>=3.0.3) ; extra == "ui" or extra == "chat" or extra == "code" or extra == "realtime"
+Requires-Dist: greenlet (>=3.0.3) ; extra == "chat"
+Requires-Dist: greenlet (>=3.0.3) ; extra == "code"
+Requires-Dist: greenlet (>=3.0.3) ; extra == "realtime"
+Requires-Dist: greenlet (>=3.0.3) ; extra == "ui"
 Requires-Dist: instructor (>=1.3.3)
 Requires-Dist: langchain-anthropic (>=0.1.13) ; extra == "anthropic"
 Requires-Dist: langchain-cohere (>=0.1.4) ; extra == "cohere"
 Requires-Dist: langchain-google-genai (>=1.0.4) ; extra == "google"
 Requires-Dist: langchain-openai (>=0.1.7) ; extra == "openai"
-Requires-Dist: litellm (>=1.41.8) ; extra == "chat" or extra == "code" or extra == "realtime"
+Requires-Dist: litellm (>=1.41.8) ; extra == "chat"
+Requires-Dist: litellm (>=1.41.8) ; extra == "code"
+Requires-Dist: litellm (>=1.41.8) ; extra == "realtime"
 Requires-Dist: markdown (>=3.5)
 Requires-Dist: openai (>=1.54.0) ; extra == "call"
-Requires-Dist: playwright (>=1.47.0) ; extra == "chat" or extra == "code"
+Requires-Dist: playwright (>=1.47.0) ; extra == "chat"
+Requires-Dist: playwright (>=1.47.0) ; extra == "code"
 Requires-Dist: plotly (>=5.24.0) ; extra == "realtime"
-Requires-Dist: praisonai-tools (>=0.0.7) ; extra == "crewai" or extra == "autogen"
-Requires-Dist: praisonaiagents (>=0.0.17)
+Requires-Dist: praisonai-tools (>=0.0.7) ; extra == "autogen"
+Requires-Dist: praisonai-tools (>=0.0.7) ; extra == "crewai"
+Requires-Dist: praisonaiagents (>=0.0.20)
 Requires-Dist: pyautogen (>=0.2.19) ; extra == "autogen"
-Requires-Dist: pydantic (<=2.10.1) ; extra == "ui" or extra == "chat" or extra == "code"
+Requires-Dist: pydantic (<=2.10.1) ; extra == "chat"
+Requires-Dist: pydantic (<=2.10.1) ; extra == "code"
+Requires-Dist: pydantic (<=2.10.1) ; extra == "ui"
 Requires-Dist: pyngrok (>=1.4.0) ; extra == "call"
 Requires-Dist: pyparsing (>=3.0.0)
 Requires-Dist: python-dotenv (>=0.19.0)
-Requires-Dist: rich (>=13.7) ; extra == "chat" or extra == "call"
-Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "ui" or extra == "chat" or extra == "code" or extra == "realtime"
-Requires-Dist: tavily-python (==0.5.0) ; extra == "chat" or extra == "code" or extra == "realtime"
+Requires-Dist: rich (>=13.7)
+Requires-Dist: rich ; extra == "call"
+Requires-Dist: rich ; extra == "chat"
+Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "chat"
+Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "code"
+Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "realtime"
+Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "ui"
+Requires-Dist: tavily-python (==0.5.0) ; extra == "chat"
+Requires-Dist: tavily-python (==0.5.0) ; extra == "code"
+Requires-Dist: tavily-python (==0.5.0) ; extra == "realtime"
 Requires-Dist: twilio (>=7.0.0) ; extra == "call"
 Requires-Dist: uvicorn (>=0.20.0) ; extra == "call"
-Requires-Dist: websockets (>=12.0) ; extra == "realtime" or extra == "call"
+Requires-Dist: websockets (>=12.0) ; extra == "call"
+Requires-Dist: websockets (>=12.0) ; extra == "realtime"
 Requires-Dist: yfinance (>=0.2.44) ; extra == "realtime"
 Project-URL: Homepage, https://docs.praison.ai
 Project-URL: Repository, https://github.com/mervinpraison/PraisonAI

{praisonai-2.0.23.dist-info → praisonai-2.0.25.dist-info}/RECORD

@@ -5,7 +5,7 @@ praisonai/api/call.py,sha256=iHdAlgIH_oTsEbjaGGu1Jjo6DTfMR-SfFdtSxnOLCeY,11032
 praisonai/auto.py,sha256=uLDm8CU3L_3amZsd55yzf9RdBF1uW-BGSx7nl9ctNZ4,8680
 praisonai/chainlit_ui.py,sha256=bNR7s509lp0I9JlJNvwCZRUZosC64qdvlFCt8NmFamQ,12216
 praisonai/cli.py,sha256=M69ji9gQGzWVLewNhTwH5kYZuj63TzlcishxoRx18ug,21210
-praisonai/deploy.py,sha256=8SOCR6yRAaoX-EpF6Snqfr_O8rfnbcOA3SAdWmLrxuk,6028
+praisonai/deploy.py,sha256=gBNkHaAdp27OeMcG42wudtqW7BSIH2DbM87bzoB2F2M,6028
 praisonai/inbuilt_tools/__init__.py,sha256=fai4ZJIKz7-iOnGZv5jJX0wmT77PKa4x2jqyaJddKFA,569
 praisonai/inbuilt_tools/autogen_tools.py,sha256=kJdEv61BTYvdHOaURNEpBcWq8Rs-oC03loNFTIjT-ak,4687
 praisonai/inc/__init__.py,sha256=sPDlYBBwdk0VlWzaaM_lG0_LD07lS2HRGvPdxXJFiYg,62
@@ -35,9 +35,12 @@ praisonai/setup.py,sha256=0jHgKnIPCtBZiGYaYyTz3PzrJI6nBy55VXk2UctXlDo,373
 praisonai/test.py,sha256=OL-wesjA5JTohr8rtr6kWoaS4ImkJg2l0GXJ-dUUfRU,4090
 praisonai/train.py,sha256=DvORlrwKOD-2v4r_z84eV3LsfzpNs-WnPKb5cQB3_t4,11071
 praisonai/ui/README.md,sha256=QG9yucvBieVjCjWFzu6hL9xNtYllkoqyJ_q1b0YYAco,1124
-praisonai/ui/agents.py,sha256=VDBm4Yp6jSllUMwDmv2UleTPmPepy8zMcMZ4G4lanKA,21381
+praisonai/ui/agents.py,sha256=ayrxHw4SCdpye5FewGQyG9cBmzzJhmataX4_6X4VNtU,27530
+praisonai/ui/callbacks.py,sha256=V4_-GjxmjDFmugUZGfQHKtNSysx7rT6i1UblbM_8lIM,1968
 praisonai/ui/chat.py,sha256=rlYwhTd3giBuvtK4Yc9kf6N9jfVT0VrZ-mLIzhANGiQ,13565
 praisonai/ui/code.py,sha256=GD_xQTo7qzpOM98tu4MOPsviJdXU__Ta3JIfsjoRe6U,15797
+praisonai/ui/colab.py,sha256=A2NceDVazMy53mIpp-NIn5w3y8aQKwQu5LmHTepVwlo,19584
+praisonai/ui/colab_chainlit.py,sha256=wrB1O0ttRlmOH8aMxU8QdGpse-X54U87ZcEEA3R1aFg,2432
 praisonai/ui/components/aicoder.py,sha256=Xh95RSEJCel5mEGic4vdtzyNpHNULF3ymft9nbwglXY,11155
 praisonai/ui/config/.chainlit/config.toml,sha256=kxb2APgVauLtfxlcEMlv8GHse6p8AbNTsJhIfZF38bg,3824
 praisonai/ui/config/.chainlit/translations/bn.json,sha256=m2TAaGMS-18_siW5dw4sbosh0Wn8ENWWzdGYkHaBrXw,22679
@@ -51,7 +54,7 @@ praisonai/ui/config/.chainlit/translations/mr.json,sha256=JaU16y5uW-cH0x7w6RDztE
 praisonai/ui/config/.chainlit/translations/ta.json,sha256=8JPW6BwLN2dl9wuq5wSkMvazcY8lM5v1pqbBxwObGUw,24724
 praisonai/ui/config/.chainlit/translations/te.json,sha256=JzW2YXWg1qqvWgIvEgMelQz5s6EzTb_uD_3TEHAHiQw,23526
 praisonai/ui/config/.chainlit/translations/zh-CN.json,sha256=aLBSSSQ0yojlYGuMMlOYvkD_ruG9-d2AgnjJWhPODVw,11737
-praisonai/ui/config/chainlit.md,sha256=zhT-Le2gShsByFXBKfayO6sM29fs3PWTfy6fG93sNJ8,33
+praisonai/ui/config/chainlit.md,sha256=YCjGjkKOeW0w711tkAdEfC6sPgBRm6G3bxYPFeHx72U,28
 praisonai/ui/config/translations/bn.json,sha256=m2TAaGMS-18_siW5dw4sbosh0Wn8ENWWzdGYkHaBrXw,22679
 praisonai/ui/config/translations/en-US.json,sha256=QoQAg8P5Q5gbGASc-HAHcfhufk71-Uc1u_ewIBfHuLc,9821
 praisonai/ui/config/translations/gu.json,sha256=9wE-NsHf7j5VUFzfE-cCpESTyHtzVHRcZXAwC3ACMl0,21660
@@ -78,8 +81,8 @@ praisonai/ui/realtimeclient/realtimedocs.txt,sha256=hmgd8Uwy2SkjSndyyF_-ZOaNxiyH
 praisonai/ui/realtimeclient/tools.py,sha256=IJOYwVOBW5Ocn5_iV9pFkmSKR3WU3YpX3kwF0I3jikQ,7855
 praisonai/ui/sql_alchemy.py,sha256=cfyL9uFfuizKFvW0aZfUBlJWPQYI-YBi1v4vxlkb1BQ,29615
 praisonai/version.py,sha256=ugyuFliEqtAwQmH4sTlc16YXKYbFWDmfyk87fErB8-8,21
-praisonai-2.0.23.dist-info/LICENSE,sha256=kqvFysVlnFxYOu0HxCe2HlmZmJtdmNGOxWRRkT9TsWc,1035
-praisonai-2.0.23.dist-info/METADATA,sha256=NpgHSV1m0uAXmleDA-HPpZXGcr0Wtlb7konsxQTbgqo,20940
-praisonai-2.0.23.dist-info/WHEEL,sha256=x1HiyTP_r-PIOu3STHzjukjf5kVLXzgVftSXf5bl8AU,110
-praisonai-2.0.23.dist-info/entry_points.txt,sha256=I_xc6a6MNTTfLxYmAxe0rgey0G-_hbY07oFW-ZDnkw4,135
-praisonai-2.0.23.dist-info/RECORD,,
+praisonai-2.0.25.dist-info/LICENSE,sha256=kqvFysVlnFxYOu0HxCe2HlmZmJtdmNGOxWRRkT9TsWc,1035
+praisonai-2.0.25.dist-info/METADATA,sha256=dPOcVl-6dVUSktySry3AaxyKJkb0ItVOtOLM5-5MVJo,21774
+praisonai-2.0.25.dist-info/WHEEL,sha256=rqU-pzVJ6on7cnU-SP20blBtY1yM7u0ejCbKCZ5K36I,110
+praisonai-2.0.25.dist-info/entry_points.txt,sha256=I_xc6a6MNTTfLxYmAxe0rgey0G-_hbY07oFW-ZDnkw4,135
+praisonai-2.0.25.dist-info/RECORD,,

{praisonai-2.0.23.dist-info → praisonai-2.0.25.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.0.0
 Root-Is-Purelib: false
 Tag: cp312-cp312-manylinux_2_39_x86_64