PraisonAI 3.0.0__py3-none-any.whl

praisonai/capabilities/videos.py

@@ -0,0 +1,141 @@
+"""
+Videos Capabilities Module
+
+Provides video generation functionality via LiteLLM.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, List, Any, Dict
+
+
+@dataclass
+class VideoResult:
+    """Result from video generation."""
+    url: Optional[str] = None
+    id: Optional[str] = None
+    status: Optional[str] = None
+    model: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+def video_generate(
+    prompt: str,
+    model: str = "runway/gen3a_turbo",
+    duration: int = 5,
+    aspect_ratio: str = "16:9",
+    timeout: float = 600.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> VideoResult:
+    """
+    Generate a video from a text prompt.
+    
+    Args:
+        prompt: Text description of the video to generate
+        model: Model name (e.g., "runway/gen3a_turbo")
+        duration: Video duration in seconds
+        aspect_ratio: Aspect ratio (e.g., "16:9", "9:16", "1:1")
+        timeout: Request timeout in seconds
+        api_key: Optional API key override
+        api_base: Optional API base URL override
+        metadata: Optional metadata for tracing
+        
+    Returns:
+        VideoResult with video URL or ID
+        
+    Example:
+        >>> result = video_generate("A sunset over the ocean")
+        >>> print(result.url)
+    """
+    import litellm
+    
+    call_kwargs = {
+        'model': model,
+        'prompt': prompt,
+        'duration': duration,
+        'aspect_ratio': aspect_ratio,
+        'timeout': timeout,
+    }
+    
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    
+    call_kwargs.update(kwargs)
+    
+    if metadata:
+        call_kwargs['metadata'] = metadata
+    
+    # Try to use video generation if available
+    try:
+        response = litellm.video_generation(**call_kwargs)
+        
+        return VideoResult(
+            url=getattr(response, 'url', None),
+            id=getattr(response, 'id', None),
+            status=getattr(response, 'status', 'completed'),
+            model=model,
+            metadata=metadata or {},
+        )
+    except AttributeError:
+        # Fallback if video_generation not available
+        raise NotImplementedError(
+            "Video generation is not yet fully supported. "
+            "Please check LiteLLM documentation for available video models."
+        )
+
+
+async def avideo_generate(
+    prompt: str,
+    model: str = "runway/gen3a_turbo",
+    duration: int = 5,
+    aspect_ratio: str = "16:9",
+    timeout: float = 600.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> VideoResult:
+    """
+    Async: Generate a video from a text prompt.
+    
+    See video_generate() for full documentation.
+    """
+    import litellm
+    
+    call_kwargs = {
+        'model': model,
+        'prompt': prompt,
+        'duration': duration,
+        'aspect_ratio': aspect_ratio,
+        'timeout': timeout,
+    }
+    
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    
+    call_kwargs.update(kwargs)
+    
+    if metadata:
+        call_kwargs['metadata'] = metadata
+    
+    try:
+        response = await litellm.avideo_generation(**call_kwargs)
+        
+        return VideoResult(
+            url=getattr(response, 'url', None),
+            id=getattr(response, 'id', None),
+            status=getattr(response, 'status', 'completed'),
+            model=model,
+            metadata=metadata or {},
+        )
+    except AttributeError:
+        raise NotImplementedError(
+            "Video generation is not yet fully supported. "
+            "Please check LiteLLM documentation for available video models."
+        )

praisonai/chainlit_ui.py

@@ -0,0 +1,304 @@
+# praisonai/chainlit_ui.py
+from praisonai.agents_generator import AgentsGenerator 
+from praisonai.auto import AutoGenerator 
+import chainlit as cl
+import os
+from chainlit.types import ThreadDict
+from chainlit.input_widget import Select, TextInput
+from typing import Optional
+from dotenv import load_dotenv
+load_dotenv()
+from contextlib import redirect_stdout
+from io import StringIO
+import logging
+logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO').upper(), format='%(asctime)s - %(levelname)s - %(message)s')
+
+framework = "crewai"
+config_list = [
+            {
+                'model': os.environ.get("OPENAI_MODEL_NAME", "gpt-5-nano"),
+                'base_url': os.environ.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
+                'api_key': os.environ.get("OPENAI_API_KEY", "")
+            }
+        ]
+agent_file = "test.yaml"
+
+actions=[
+       cl.Action(name="run", payload={"value": "run"}, label="run"),
+    cl.Action(name="modify", payload={"value": "modify"}, label="Modify"),
+]
+
+@cl.action_callback("run")
+async def on_run(action):
+    await main(cl.Message(content=""))
+
+@cl.action_callback("modify")
+async def on_modify(action):
+    await cl.Message(content="Modify the agents and tools from below settings").send()
+    
+
+@cl.set_chat_profiles
+async def set_profiles(current_user: cl.User):
+    return [
+        cl.ChatProfile(
+            name="Auto",
+            markdown_description="Automatically generate agents and tasks based on your input.",
+            starters=[
+                cl.Starter(
+                    label="Create a movie script",
+                    message="Create a movie script about a futuristic society where AI and humans coexist, focusing on the conflict and resolution between them. Start with an intriguing opening scene.",
+                    icon="/public/movie.svg",
+                ),
+                cl.Starter(
+                    label="Design a fantasy world",
+                    message="Design a detailed fantasy world with unique geography, cultures, and magical systems. Start by describing the main continent and its inhabitants.",
+                    icon="/public/fantasy.svg",
+                ),
+                cl.Starter(
+                    label="Write a futuristic political thriller",
+                    message="Write a futuristic political thriller involving a conspiracy within a global government. Start with a high-stakes meeting that sets the plot in motion.",
+                    icon="/public/thriller.svg",
+                ),
+                cl.Starter(
+                    label="Develop a new board game",
+                    message="Develop a new, innovative board game. Describe the game's objective, rules, and unique mechanics. Create a scenario to illustrate gameplay.",
+                    icon="/public/game.svg",
+                ),
+            ]
+        ),
+        cl.ChatProfile(
+            name="Manual",
+            markdown_description="Manually define your agents and tasks using a YAML file.",
+        ),
+    ]
+
+
+@cl.on_chat_start
+async def start_chat():
+    cl.user_session.set(
+        "message_history",
+        [{"role": "system", "content": "You are a helpful assistant."}],
+    )
+    
+    # Create tools.py if it doesn't exist
+    if not os.path.exists("tools.py"):
+        with open("tools.py", "w") as f:
+            f.write("# Add your custom tools here\n")
+    
+    settings = await cl.ChatSettings(
+        [
+            TextInput(id="Model", label="OpenAI - Model", initial=config_list[0]['model']),
+            TextInput(id="BaseUrl", label="OpenAI - Base URL", initial=config_list[0]['base_url']),
+            TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']), 
+            Select(
+                id="Framework",
+                label="Framework",
+                values=["crewai", "autogen"],
+                initial_index=0,
+            ),
+        ]
+    ).send()
+    cl.user_session.set("settings", settings)
+    chat_profile = cl.user_session.get("chat_profile")
+    if chat_profile=="Manual":
+        
+        agent_file = "agents.yaml"
+        full_agent_file_path = os.path.abspath(agent_file)  # Get full path
+        if os.path.exists(full_agent_file_path):
+            with open(full_agent_file_path, 'r') as f:
+                yaml_content = f.read()
+            msg = cl.Message(content=yaml_content, language="yaml")
+            await msg.send()
+            
+                
+        full_tools_file_path = os.path.abspath("tools.py")  # Get full path
+        if os.path.exists(full_tools_file_path):
+            with open(full_tools_file_path, 'r') as f:
+                tools_content = f.read()
+            msg = cl.Message(content=tools_content, language="python")
+            await msg.send()
+
+        settings = await cl.ChatSettings(
+            [
+                TextInput(id="Model", label="OpenAI - Model", initial=config_list[0]['model']),
+                TextInput(id="BaseUrl", label="OpenAI - Base URL", initial=config_list[0]['base_url']),
+                TextInput(id="ApiKey", label="OpenAI - API Key", initial=config_list[0]['api_key']), 
+                Select(
+                    id="Framework",
+                    label="Framework",
+                    values=["crewai", "autogen"],
+                    initial_index=0,
+                ),
+                TextInput(id="agents", label="agents.yaml", initial=yaml_content, multiline=True),
+                TextInput(id="tools", label="tools.py", initial=tools_content, multiline=True),
+            ]
+        ).send()
+        cl.user_session.set("settings", settings)
+        
+        res = await cl.AskActionMessage(
+            content="Pick an action!",
+            actions=actions,
+        ).send()
+        if res and res.get("value") == "modify":
+            await cl.Message(content="Modify the agents and tools from below settings", actions=actions).send()
+        elif res and res.get("value") == "run":
+            await main(cl.Message(content="", actions=actions))
+
+    await on_settings_update(settings)
+    
+@cl.on_settings_update
+async def on_settings_update(settings):
+    """Handle updates to the ChatSettings form."""
+    global config_list, framework
+    config_list[0]['model'] = settings["Model"]
+    config_list[0]['base_url'] = settings["BaseUrl"]
+    config_list[0]['api_key'] = settings["ApiKey"]
+    os.environ["OPENAI_API_KEY"] = config_list[0]['api_key']
+    os.environ["OPENAI_MODEL_NAME"] = config_list[0]['model']
+    os.environ["OPENAI_API_BASE"] = config_list[0]['base_url']
+    framework = settings["Framework"]
+    
+    if "agents" in settings:
+        with open("agents.yaml", "w") as f:
+            f.write(settings["agents"])
+    if "tools" in settings:
+        with open("tools.py", "w") as f:
+            f.write(settings["tools"])
+    
+    print("Settings updated")
+
+@cl.on_chat_resume
+async def on_chat_resume(thread: ThreadDict):
+    message_history = cl.user_session.get("message_history", [])
+    root_messages = [m for m in thread["steps"] if m["parentId"] is None]
+    for message in root_messages:
+        if message["type"] == "user_message":
+            message_history.append({"role": "user", "content": message["output"]})
+        elif message["type"] == "ai_message":
+            message_history.append({"role": "assistant", "content": message["content"]})
+    cl.user_session.set("message_history", message_history)
+
+# @cl.step(type="tool")
+# async def tool(data: Optional[str] = None, language: Optional[str] = None):
+#     return cl.Message(content=data, language=language)
+
+@cl.step(type="tool", show_input=False)
+async def run_agents(agent_file: str, framework: str):
+    """Runs the agents and returns the result."""
+    agents_generator = AgentsGenerator(agent_file, framework, config_list)
+    current_step = cl.context.current_step
+    print("Current Step:", current_step)
+
+    stdout_buffer = StringIO()
+    with redirect_stdout(stdout_buffer):
+        result = agents_generator.generate_crew_and_kickoff()
+        
+    complete_output = stdout_buffer.getvalue()
+
+    async with cl.Step(name="gpt4", type="llm", show_input=True) as step:
+        step.input = ""
+        
+        for line in stdout_buffer.getvalue().splitlines():
+            print(line)
+            await step.stream_token(line)
+            
+        tool_res = await output(complete_output)
+
+    yield result
+
+@cl.step(type="tool", show_input=False, language="yaml")
+async def output(output):
+    return output
+
+@cl.step(type="tool", show_input=False, language="yaml")
+def agent(output):
+    return(f"""
+        Agent Step Completed!
+        Output: {output}
+    """)
+
+@cl.step(type="tool", show_input=False, language="yaml")
+def task(output):
+    return(f"""
+        Task Completed!
+        Task: {output.description}
+        Output: {output.raw_output}
+        {output}
+    """)
+
+@cl.on_message
+async def main(message: cl.Message):
+    """Run PraisonAI with the provided message as the topic."""
+    message_history = cl.user_session.get("message_history")
+    if message_history is None:
+        message_history = []
+        cl.user_session.set("message_history", message_history)
+    message_history.append({"role": "user", "content": message.content})
+    topic = message.content
+    chat_profile = cl.user_session.get("chat_profile")
+
+    if chat_profile == "Auto":
+        agent_file = "agents.yaml"
+        generator = AutoGenerator(topic=topic, agent_file=agent_file, framework=framework, config_list=config_list)
+        await cl.sleep(2)
+        agent_file = generator.generate()
+        agents_generator = AgentsGenerator(
+            agent_file, 
+            framework, 
+            config_list, 
+            # agent_callback=agent,
+            # task_callback=task
+        )
+        # Capture stdout
+        stdout_buffer = StringIO()
+        with redirect_stdout(stdout_buffer):
+            result = agents_generator.generate_crew_and_kickoff()
+            
+        complete_output = stdout_buffer.getvalue()
+        tool_res = await output(complete_output)
+        msg = cl.Message(content=result)
+        await msg.send()
+        message_history.append({"role": "assistant", "content": message.content})
+    else:  # chat_profile == "Manual"
+        agent_file = "agents.yaml"
+        full_agent_file_path = os.path.abspath(agent_file)  # Get full path
+        full_tools_file_path = os.path.abspath("tools.py")  
+        if os.path.exists(full_agent_file_path):
+            with open(full_agent_file_path, 'r') as f:
+                yaml_content = f.read()
+            # tool_res = await tool()
+            msg_agents = cl.Message(content=yaml_content, language="yaml")
+            await msg_agents.send()
+            if os.path.exists(full_tools_file_path):
+                with open(full_tools_file_path, 'r') as f:
+                    tools_content = f.read()
+                msg_tools = cl.Message(content=tools_content, language="python")
+                await msg_tools.send()
+        else:
+            # If the file doesn't exist, follow the same process as "Auto"
+            generator = AutoGenerator(topic=topic, agent_file=agent_file, framework=framework, config_list=config_list)
+            agent_file = generator.generate()
+
+        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()
+        message_history.append({"role": "assistant", "content": message.content})
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Get username and password from environment variables
+username = os.getenv("CHAINLIT_USERNAME", "admin")  # Default to "admin" if not found
+password = os.getenv("CHAINLIT_PASSWORD", "admin")  # Default to "admin" if not found
+
+@cl.password_auth_callback
+def auth_callback(username: str, password: str):
+    # Fetch the user matching username from your database
+    # and compare the hashed password with the value stored in the database
+    if (username, password) == (username, password):
+        return cl.User(
+            identifier=username, metadata={"role": "ADMIN", "provider": "credentials"}
+        )
+    else:
+        return None

praisonai/chat/__init__.py

@@ -0,0 +1,106 @@
+"""
+PraisonAI Chat Module
+
+This module provides the chat UI integration for PraisonAI agents.
+It uses the PraisonAI Chat (based on Chainlit) for the frontend.
+"""
+
+from typing import Optional, Any
+
+__all__ = ["start_chat_server", "ChatConfig"]
+
+
+class ChatConfig:
+    """Configuration for the PraisonAI Chat server."""
+    
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        debug: bool = False,
+        auth_enabled: bool = False,
+        session_id: Optional[str] = None,
+    ):
+        self.host = host
+        self.port = port
+        self.debug = debug
+        self.auth_enabled = auth_enabled
+        self.session_id = session_id
+
+
+def start_chat_server(
+    agent: Optional[Any] = None,
+    agents: Optional[list] = None,
+    config: Optional[ChatConfig] = None,
+    port: int = 8000,
+    host: str = "0.0.0.0",
+    debug: bool = False,
+) -> None:
+    """
+    Start the PraisonAI Chat server.
+    
+    Args:
+        agent: A single PraisonAI agent to use in the chat.
+        agents: A list of PraisonAI agents for multi-agent chat.
+        config: ChatConfig object with server settings.
+        port: Port to run the server on (default: 8000).
+        host: Host to bind to (default: 0.0.0.0).
+        debug: Enable debug mode (default: False).
+    
+    Example:
+        >>> from praisonaiagents import Agent
+        >>> from praisonai.chat import start_chat_server
+        >>> 
+        >>> agent = Agent(name="Assistant", instructions="You are helpful.")
+        >>> start_chat_server(agent=agent, port=8000)
+    """
+    # Lazy import to avoid loading chainlit unless needed
+    try:
+        from chainlit.cli import run_chainlit
+    except ImportError:
+        raise ImportError(
+            "PraisonAI Chat requires the 'praisonai-chat' package. "
+            "Install it with: pip install praisonai-chat"
+        )
+    
+    if config is None:
+        config = ChatConfig(host=host, port=port, debug=debug)
+    
+    # Store agents in a way accessible to the chainlit app
+    import os
+    os.environ["PRAISONAI_CHAT_MODE"] = "true"
+    
+    if agent is not None:
+        # Single agent mode
+        _register_agent(agent)
+    elif agents is not None:
+        # Multi-agent mode
+        for a in agents:
+            _register_agent(a)
+    
+    # Start the chainlit server
+    from pathlib import Path
+    
+    # Use the built-in app file
+    app_file = Path(__file__).parent / "app.py"
+    
+    # Set environment variables for chainlit
+    os.environ["CHAINLIT_HOST"] = config.host
+    os.environ["CHAINLIT_PORT"] = str(config.port)
+    
+    run_chainlit(str(app_file))
+
+
+# Global registry for agents
+_REGISTERED_AGENTS: dict = {}
+
+
+def _register_agent(agent: Any) -> None:
+    """Register an agent for use in the chat UI."""
+    agent_name = getattr(agent, "name", None) or getattr(agent, "role", "Agent")
+    _REGISTERED_AGENTS[agent_name] = agent
+
+
+def get_registered_agents() -> dict:
+    """Get all registered agents."""
+    return _REGISTERED_AGENTS

praisonai/chat/app.py

@@ -0,0 +1,125 @@
+"""
+PraisonAI Chat - Default Chainlit Application
+
+This is the default chat application that runs when using `praisonai chat`.
+It integrates with PraisonAI agents for multi-agent conversations.
+"""
+
+import os
+import chainlit as cl
+
+# Check if we're in PraisonAI Chat mode with registered agents
+PRAISONAI_CHAT_MODE = os.environ.get("PRAISONAI_CHAT_MODE", "false").lower() == "true"
+
+
+def get_agents():
+    """Get registered agents from the chat module."""
+    try:
+        from praisonai.chat import get_registered_agents
+        return get_registered_agents()
+    except ImportError:
+        return {}
+
+
+@cl.on_chat_start
+async def on_chat_start():
+    """Initialize the chat session."""
+    agents = get_agents()
+    
+    if agents:
+        agent_names = list(agents.keys())
+        cl.user_session.set("agents", agents)
+        cl.user_session.set("current_agent", agent_names[0] if agent_names else None)
+        
+        await cl.Message(
+            content=f"Welcome to PraisonAI Chat! Available agents: {', '.join(agent_names)}"
+        ).send()
+    else:
+        await cl.Message(
+            content="Welcome to PraisonAI Chat! No agents configured. "
+                    "Use the API to register agents or configure via YAML."
+        ).send()
+    
+    cl.user_session.set("message_history", [])
+
+
+@cl.on_message
+async def on_message(message: cl.Message):
+    """Handle incoming messages."""
+    agents = cl.user_session.get("agents", {})
+    current_agent_name = cl.user_session.get("current_agent")
+    message_history = cl.user_session.get("message_history", [])
+    
+    # Add user message to history
+    message_history.append({"role": "user", "content": message.content})
+    
+    if not agents or not current_agent_name:
+        # No agents configured - use a simple echo response
+        response = f"Echo: {message.content}\n\n(No agents configured. Register agents to enable AI responses.)"
+        await cl.Message(content=response).send()
+        return
+    
+    agent = agents.get(current_agent_name)
+    if agent is None:
+        await cl.Message(content=f"Agent '{current_agent_name}' not found.").send()
+        return
+    
+    # Create a step for the agent response
+    async with cl.Step(name=current_agent_name, type="llm") as step:
+        step.input = message.content
+        
+        try:
+            # Try to call the agent
+            if hasattr(agent, "chat"):
+                # PraisonAI Agent with chat method
+                response = await _call_agent_async(agent, message.content)
+            elif hasattr(agent, "run"):
+                # Agent with run method
+                response = await _call_agent_async(agent, message.content, method="run")
+            elif callable(agent):
+                # Callable agent
+                response = agent(message.content)
+            else:
+                response = f"Agent '{current_agent_name}' does not have a callable interface."
+            
+            step.output = str(response)
+            
+        except Exception as e:
+            response = f"Error calling agent: {str(e)}"
+            step.output = response
+    
+    # Add assistant response to history
+    message_history.append({"role": "assistant", "content": str(response)})
+    cl.user_session.set("message_history", message_history)
+    
+    # Send the response
+    await cl.Message(content=str(response)).send()
+
+
+async def _call_agent_async(agent, message: str, method: str = "chat"):
+    """Call an agent method, handling both sync and async."""
+    import asyncio
+    
+    func = getattr(agent, method)
+    
+    if asyncio.iscoroutinefunction(func):
+        return await func(message)
+    else:
+        # Run sync function in thread pool
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, func, message)
+
+
+@cl.on_chat_resume
+async def on_chat_resume(thread):
+    """Resume a chat session."""
+    message_history = []
+    
+    root_messages = [m for m in thread.get("steps", []) if m.get("parentId") is None]
+    for msg in root_messages:
+        if msg.get("type") == "user_message":
+            message_history.append({"role": "user", "content": msg.get("output", "")})
+        elif msg.get("type") == "assistant_message":
+            message_history.append({"role": "assistant", "content": msg.get("output", "")})
+    
+    cl.user_session.set("message_history", message_history)