PraisonAI 1.0.8__tar.gz → 2.0.1__tar.gz

{praisonai-1.0.8 → praisonai-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PraisonAI
-Version: 1.0.8
+Version: 2.0.1
 Summary: PraisonAI application combines AutoGen and CrewAI or similar frameworks into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration.
 Author: Mervin Praison
 Requires-Python: >=3.10,<3.13
@@ -23,9 +23,10 @@ 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 == "chat" or extra == "code" or extra == "realtime"
-Requires-Dist: chainlit (==1.3.0rc1) ; 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: duckduckgo_search (>=6.3.0) ; extra == "realtime"
@@ -45,11 +46,12 @@ Requires-Dist: openai (>=1.54.0) ; extra == "call"
 Requires-Dist: playwright (>=1.47.0) ; extra == "chat" or 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.4)
 Requires-Dist: pyautogen (>=0.2.19) ; extra == "autogen"
 Requires-Dist: pydantic (<=2.10.1) ; extra == "chat" or extra == "code"
 Requires-Dist: pyngrok (>=1.4.0) ; extra == "call"
 Requires-Dist: pyparsing (>=3.0.0)
-Requires-Dist: python-dotenv (>=0.19.0) ; extra == "call"
+Requires-Dist: python-dotenv (>=1.0.1) ; extra == "call"
 Requires-Dist: rich (>=13.7) ; extra == "chat" or extra == "call"
 Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "chat" or extra == "code" or extra == "realtime"
 Requires-Dist: tavily-python (==0.5.0) ; extra == "chat" or extra == "code" or extra == "realtime"
@@ -121,19 +123,6 @@ Praison AI, leveraging both AutoGen and CrewAI or any other agent framework, rep
 pip install praisonai
 ```
 
-### Using uv (Fast Python Package Installer)
-```bash
-# Install uv if you haven't already
-pip install uv
-
-# Install from requirements
-uv pip install -r pyproject.toml
-
-# Install with extras
-uv pip install -r pyproject.toml --extra code
-uv pip install -r pyproject.toml --extra "crewai,autogen"
-```
-
 ### Framework-specific Installation
 ```bash
 # Install with CrewAI support
@@ -455,6 +444,19 @@ if __name__ == "__main__":
 
 This configuration ensures that your development dependencies are correctly categorized and installed as needed.
 
+### Using uv (Fast Python Package Installer)
+```bash
+# Install uv if you haven't already
+pip install uv
+
+# Install from requirements
+uv pip install -r pyproject.toml
+
+# Install with extras
+uv pip install -r pyproject.toml --extra code
+uv pip install -r pyproject.toml --extra "crewai,autogen"
+```
+
 ## Contributing
 
 - Fork on GitHub: Use the "Fork" button on the repository page.

{praisonai-1.0.8 → praisonai-2.0.1}/praisonai/agents_generator.py

@@ -20,6 +20,13 @@ CREWAI_AVAILABLE = False
 AUTOGEN_AVAILABLE = False
 PRAISONAI_TOOLS_AVAILABLE = False
 AGENTOPS_AVAILABLE = False
+PRAISONAI_AVAILABLE = False
+
+try:
+    from praisonaiagents import Agent as PraisonAgent, Task as PraisonTask, PraisonAIAgents
+    PRAISONAI_AVAILABLE = True
+except ImportError:
+    pass
 
 try:
     from crewai import Agent, Task, Crew
@@ -37,11 +44,14 @@ except ImportError:
 try:
     import agentops
     AGENTOPS_AVAILABLE = True
+    AGENTOPS_API_KEY = os.getenv("AGENTOPS_API_KEY")
+    if not AGENTOPS_API_KEY:
+        AGENTOPS_AVAILABLE = False
 except ImportError:
     pass
 
 # Only try to import praisonai_tools if either CrewAI or AutoGen is available
-if CREWAI_AVAILABLE or AUTOGEN_AVAILABLE:
+if CREWAI_AVAILABLE or AUTOGEN_AVAILABLE or PRAISONAI_AVAILABLE:
     try:
         from praisonai_tools import (
             CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool, DirectoryReadTool,
@@ -115,6 +125,8 @@ class AgentsGenerator:
             raise ImportError("CrewAI is not installed. Please install it with 'pip install praisonai[crewai]'")
         elif framework == "autogen" and not AUTOGEN_AVAILABLE:
             raise ImportError("AutoGen is not installed. Please install it with 'pip install praisonai[autogen]'")
+        elif framework == "praisonai" and not PRAISONAI_AVAILABLE:
+            raise ImportError("PraisonAI is not installed. Please install it with 'pip install praisonaiagents'")
 
     def is_function_or_decorated(self, obj):
         """
@@ -221,7 +233,7 @@ class AgentsGenerator:
         tools_dict = {}
         
         # Only try to use praisonai_tools if it's available and needed
-        if PRAISONAI_TOOLS_AVAILABLE and (CREWAI_AVAILABLE or AUTOGEN_AVAILABLE):
+        if PRAISONAI_TOOLS_AVAILABLE and (CREWAI_AVAILABLE or AUTOGEN_AVAILABLE or PRAISONAI_AVAILABLE):
             tools_dict = {
                 'CodeDocsSearchTool': CodeDocsSearchTool(),
                 'CSVSearchTool': CSVSearchTool(),
@@ -266,13 +278,19 @@ class AgentsGenerator:
             if not AUTOGEN_AVAILABLE:
                 raise ImportError("AutoGen is not installed. Please install it with 'pip install praisonai[autogen]'")
             if AGENTOPS_AVAILABLE:
-                agentops.init(os.environ.get("AGENTOPS_API_KEY"), tags=["autogen"])
+                agentops.init(os.environ.get("AGENTOPS_API_KEY"), default_tags=["autogen"])
             return self._run_autogen(config, topic, tools_dict)
+        elif framework == "praisonai":
+            if not PRAISONAI_AVAILABLE:
+                raise ImportError("PraisonAI is not installed. Please install it with 'pip install praisonaiagents'")
+            if AGENTOPS_AVAILABLE:
+                agentops.init(os.environ.get("AGENTOPS_API_KEY"), default_tags=["praisonai"])
+            return self._run_praisonai(config, topic, tools_dict)
         else:  # framework=crewai
             if not CREWAI_AVAILABLE:
                 raise ImportError("CrewAI is not installed. Please install it with 'pip install praisonai[crewai]'")
             if AGENTOPS_AVAILABLE:
-                agentops.init(os.environ.get("AGENTOPS_API_KEY"), tags=["crewai"])
+                agentops.init(os.environ.get("AGENTOPS_API_KEY"), default_tags=["crewai"])
             return self._run_crewai(config, topic, tools_dict)
 
     def _run_autogen(self, config, topic, tools_dict):
@@ -472,3 +490,126 @@ class AgentsGenerator:
             
         return result
 
+    def _run_praisonai(self, config, topic, tools_dict):
+        """
+        Run agents using the PraisonAI framework.
+        """
+        agents = {}
+        tasks = []
+        tasks_dict = {}
+
+        # Create agents from config
+        for role, details in config['roles'].items():
+            role_filled = details['role'].format(topic=topic)
+            goal_filled = details['goal'].format(topic=topic)
+            backstory_filled = details['backstory'].format(topic=topic)
+            
+            # Get agent tools
+            agent_tools = [tools_dict[tool] for tool in details.get('tools', []) 
+                          if tool in tools_dict]
+            
+            # Configure LLM
+            llm_model = details.get('llm')
+            if llm_model:
+                llm = llm_model.get("model", os.environ.get("MODEL_NAME", "gpt-4o"))
+            else:
+                llm = os.environ.get("MODEL_NAME", "gpt-4o")
+
+            # Configure function calling LLM
+            function_calling_llm_model = details.get('function_calling_llm')
+            if function_calling_llm_model:
+                function_calling_llm = function_calling_llm_model.get("model", os.environ.get("MODEL_NAME", "openai/gpt-4o"))
+            else:
+                function_calling_llm = os.environ.get("MODEL_NAME", "gpt-4o")
+            
+            # Create PraisonAI agent
+            agent = PraisonAgent(
+                name=role_filled,
+                role=role_filled,
+                goal=goal_filled,
+                backstory=backstory_filled,
+                tools=agent_tools,
+                allow_delegation=details.get('allow_delegation', False),
+                llm=llm,
+                function_calling_llm=function_calling_llm,
+                max_iter=details.get('max_iter', 15),
+                max_rpm=details.get('max_rpm'),
+                max_execution_time=details.get('max_execution_time'),
+                verbose=details.get('verbose', True),
+                cache=details.get('cache', True),
+                system_template=details.get('system_template'),
+                prompt_template=details.get('prompt_template'),
+                response_template=details.get('response_template'),
+            )
+            
+            # Set agent callback if provided
+            if self.agent_callback:
+                agent.step_callback = self.agent_callback
+
+            agents[role] = agent
+
+            # 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)
+
+                # Create task using PraisonAI Task class
+                task = PraisonTask(
+                    description=description_filled,
+                    expected_output=expected_output_filled,
+                    agent=agent,
+                    tools=task_details.get('tools', []),
+                    async_execution=task_details.get('async_execution', False),
+                    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_details.get('callback'),
+                    create_directory=task_details.get('create_directory', False)
+                )
+                
+                # Set task callback if provided
+                if self.task_callback:
+                    task.callback = self.task_callback
+
+                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
+
+        # Create and run the PraisonAI agents
+        if config.get('process') == 'hierarchical':
+            agents = PraisonAIAgents(
+                agents=list(agents.values()),
+                tasks=tasks,
+                verbose=True,
+                process="hierarchical",
+                manager_llm=config.get('manager_llm', 'gpt-4o'),
+            )
+        else:
+            agents = PraisonAIAgents(
+                agents=list(agents.values()),
+                tasks=tasks,
+                verbose=2
+            )
+        
+        self.logger.debug("Final Configuration:")
+        self.logger.debug(f"Agents: {agents.agents}")
+        self.logger.debug(f"Tasks: {agents.tasks}")
+
+        response = agents.start()
+        # result = f"### Task Output ###\n{response}"
+        self.logger.debug(f"Result: {response}")
+        result = ""
+        
+        if AGENTOPS_AVAILABLE:
+            agentops.end_session("Success")
+            
+        return result

{praisonai-1.0.8 → praisonai-2.0.1}/praisonai/auto.py

@@ -12,6 +12,13 @@ import logging
 CREWAI_AVAILABLE = False
 AUTOGEN_AVAILABLE = False
 PRAISONAI_TOOLS_AVAILABLE = False
+PRAISONAI_AVAILABLE = False
+
+try:
+    from praisonaiagents import Agent as PraisonAgent, Task as PraisonTask, PraisonAIAgents
+    PRAISONAI_AVAILABLE = True
+except ImportError:
+    pass
 
 try:
     from crewai import Agent, Task, Crew
@@ -71,6 +78,11 @@ CrewAI is not installed. Please install with:
 AutoGen is not installed. Please install with:
     pip install "praisonai[autogen]"
 """)
+        elif framework == "praisonai" and not PRAISONAI_AVAILABLE:
+            raise ImportError("""
+Praisonai is not installed. Please install with:
+    pip install praisonaiagents
+""")
 
         # Only show tools message if using a framework and tools are needed
         if (framework in ["crewai", "autogen"]) and not PRAISONAI_TOOLS_AVAILABLE:
@@ -88,7 +100,7 @@ Tools are not available for {framework}. To use tools, install:
         ]
         self.topic = topic
         self.agent_file = agent_file
-        self.framework = framework or "crewai"
+        self.framework = framework or "praisonai"
         self.client = instructor.patch(
             OpenAI(
                 base_url=self.config_list[0]['base_url'],

{praisonai-1.0.8 → praisonai-2.0.1}/praisonai/cli.py

@@ -24,11 +24,19 @@ GRADIO_AVAILABLE = False
 CALL_MODULE_AVAILABLE = False
 CREWAI_AVAILABLE = False
 AUTOGEN_AVAILABLE = False
+PRAISONAI_AVAILABLE = False
 
 try:
-    # Set CHAINLIT_APP_ROOT only if it doesn't exist
+    # Create necessary directories and set CHAINLIT_APP_ROOT
     if "CHAINLIT_APP_ROOT" not in os.environ:
-        os.environ["CHAINLIT_APP_ROOT"] = os.path.join(os.path.expanduser("~"), ".praison")
+        chainlit_root = os.path.join(os.path.expanduser("~"), ".praison")
+        os.environ["CHAINLIT_APP_ROOT"] = chainlit_root
+    else:
+        chainlit_root = os.environ["CHAINLIT_APP_ROOT"]
+        
+    os.makedirs(chainlit_root, exist_ok=True)
+    os.makedirs(os.path.join(chainlit_root, ".files"), exist_ok=True)
+    
     from chainlit.cli import chainlit_run
     CHAINLIT_AVAILABLE = True
 except ImportError:
@@ -58,6 +66,12 @@ try:
 except ImportError:
     pass
 
+try:
+    from praisonaiagents import Agent as PraisonAgent, Task as PraisonTask, PraisonAIAgents
+    PRAISONAI_AVAILABLE = True
+except ImportError:
+    pass
+
 logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO'), format='%(asctime)s - %(levelname)s - %(message)s')
 
 def stream_subprocess(command, env=None):
@@ -266,7 +280,7 @@ class PraisonAI:
         Parse the command-line arguments for the PraisonAI CLI.
         """
         parser = argparse.ArgumentParser(prog="praisonai", description="praisonAI command-line interface")
-        parser.add_argument("--framework", choices=["crewai", "autogen"], help="Specify the framework")
+        parser.add_argument("--framework", choices=["crewai", "autogen", "praisonai"], help="Specify the framework")
         parser.add_argument("--ui", choices=["chainlit", "gradio"], help="Specify the UI framework (gradio or chainlit).")
         parser.add_argument("--auto", nargs=argparse.REMAINDER, help="Enable auto mode and pass arguments for it")
         parser.add_argument("--init", nargs=argparse.REMAINDER, help="Initialize agents with optional topic")
@@ -374,11 +388,12 @@ class PraisonAI:
 
         # Only check framework availability for agent-related operations
         if not args.command and (args.init or args.auto or args.framework):
-            if not CREWAI_AVAILABLE and not AUTOGEN_AVAILABLE:
+            if not CREWAI_AVAILABLE and not AUTOGEN_AVAILABLE and not PRAISONAI_AVAILABLE:
                 print("[red]ERROR: No framework is installed. Please install at least one framework:[/red]")
                 print("\npip install \"praisonai\\[crewai]\"  # For CrewAI")
                 print("pip install \"praisonai\\[autogen]\"  # For AutoGen")
                 print("pip install \"praisonai\\[crewai,autogen]\"  # For both frameworks\n")
+                print("pip install praisonaiagents # For PraisonAIAgents\n")  
                 sys.exit(1)
 
         return args
@@ -393,15 +408,6 @@ class PraisonAI:
             root_path = os.path.join(os.path.expanduser("~"), ".praison")
             if "CHAINLIT_APP_ROOT" not in os.environ:
                 os.environ["CHAINLIT_APP_ROOT"] = root_path
-            public_folder = os.path.join(os.path.dirname(praisonai.__file__), 'public')
-            if not os.path.exists(os.path.join(root_path, "public")):
-                if os.path.exists(public_folder):
-                    shutil.copytree(public_folder, os.path.join(root_path, "public"), dirs_exist_ok=True)
-                    logging.info("Public folder copied successfully!")
-                else:
-                    logging.info("Public folder not found in the package.")
-            else:
-                logging.info("Public folder already exists.")
             chat_ui_path = os.path.join(os.path.dirname(praisonai.__file__), 'ui', 'chat.py')
             chainlit_run([chat_ui_path])
         else:

{praisonai-1.0.8 → praisonai-2.0.1}/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==1.0.8 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==2.0.1 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

praisonai-2.0.1/praisonai/ui/components/aicoder.py

@@ -0,0 +1,269 @@
+import os
+import asyncio
+from pathlib import Path
+import difflib
+from typing import Dict, Any
+from litellm import acompletion
+import json
+import dotenv
+from tavily import TavilyClient
+from crawl4ai import AsyncWebCrawler
+
+dotenv.load_dotenv()
+
+class AICoder:
+    def __init__(self, cwd: str = None, tavily_api_key: str = None):
+        self.cwd = cwd or os.getcwd()
+        self.tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "write_to_file",
+                    "description": "Write content to a file at the specified path. If the file exists, it will be overwritten.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "path": {
+                                "type": "string",
+                                "description": "The path of the file to write to."
+                            },
+                            "content": {
+                                "type": "string",
+                                "description": "The content to write to the file."
+                            }
+                        },
+                        "required": ["path", "content"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "execute_command",
+                    "description": "Execute a CLI command on the system.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "command": {
+                                "type": "string",
+                                "description": "The CLI command to execute."
+                            }
+                        },
+                        "required": ["command"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "read_file",
+                    "description": "Read the contents of a file at the specified path.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "path": {
+                                "type": "string",
+                                "description": "The path of the file to read."
+                            }
+                        },
+                        "required": ["path"]
+                    }
+                }
+            }
+        ]
+
+        self.tavily_api_key = tavily_api_key
+        if self.tavily_api_key:
+            self.tavily_client = TavilyClient(api_key=self.tavily_api_key)
+            self.tools.append({
+                "type": "function",
+                "function": {
+                    "name": "tavily_web_search",
+                    "description": "Search the web using Tavily API and crawl the resulting URLs",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string", "description": "Search query"}
+                        },
+                        "required": ["query"]
+                    }
+                }
+            })
+        else:
+            self.tavily_client = None
+
+    async def create_directories(self, file_path):
+        file_path_obj = Path(file_path)
+        dir_path = file_path_obj.parent
+        if not dir_path.exists():
+            os.makedirs(dir_path, exist_ok=True)
+        return dir_path
+
+    async def file_exists(self, file_path):
+        return Path(file_path).exists()
+
+    async def write_to_file(self, file_path, content, existing=False):
+        if not existing:
+            await self.create_directories(file_path)
+        try:
+            with open(file_path, 'w') as file:
+                file.write(content)
+            return True
+        except Exception as e:
+            return False
+
+    async def read_file(self, file_path):
+        try:
+            with open(file_path, 'r') as file:
+                return file.read()
+        except:
+            return None
+
+    async def execute_command(self, command: str):
+        try:
+            process = await asyncio.create_subprocess_shell(
+                command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=self.cwd
+            )
+            stdout, stderr = await process.communicate()
+            if stdout:
+                return f"Command output:\n{stdout.decode()}"
+            if stderr:
+                return f"Command error:\n{stderr.decode()}"
+            return process.returncode == 0
+        except Exception as e:
+            return f"Error executing command: {str(e)}"
+
+    async def tavily_web_search(self, query):
+        if not self.tavily_client:
+            return json.dumps({
+                "query": query,
+                "error": "Tavily API key is not set. Web search is unavailable."
+            })
+        response = self.tavily_client.search(query)
+        results = []
+        async with AsyncWebCrawler() as crawler:
+            for result in response.get('results', []):
+                url = result.get('url')
+                if url:
+                    try:
+                        crawl_result = await crawler.arun(url=url)
+                        results.append({
+                            "content": result.get('content'),
+                            "url": url,
+                            "full_content": crawl_result.markdown
+                        })
+                    except Exception:
+                        results.append({
+                            "content": result.get('content'),
+                            "url": url,
+                            "full_content": "Error: Unable to crawl this URL"
+                        })
+        return json.dumps({
+            "query": query,
+            "results": results
+        })
+
+    def generate_diff(self, original_content: str, new_content: str, filename="file.txt"):
+        diff_lines = difflib.unified_diff(
+            original_content.splitlines(keepends=True),
+            new_content.splitlines(keepends=True),
+            fromfile=f"original_{filename}",
+            tofile=f"modified_{filename}"
+        )
+        return "".join(diff_lines)
+
+    def parse_json_response(self, json_object: Dict) -> Dict[str, Any]:
+        if 'choices' in json_object and json_object['choices'][0]['message']:
+            message = json_object['choices'][0]['message']
+            if 'tool_calls' in message and message['tool_calls']:
+                return {"type": "tool_calls", "data": message['tool_calls']}
+            return {"type": "content", "data": message.get('content', "")}
+        return {"type": "content", "data": json.dumps(json_object)}
+
+    def parse_llm_response(self, response: Any) -> Dict[str, Any]:
+        if response is None:
+            return {"type": "content", "data": ""}
+        if isinstance(response, str):
+            try:
+                json_object = json.loads(response)
+                if isinstance(json_object, dict):
+                    return self.parse_json_response(json_object)
+            except json.JSONDecodeError:
+                return {"type": "content", "data": response}
+        if hasattr(response, 'choices') and response.choices:
+            message = response.choices[0].message
+            if hasattr(message, 'tool_calls') and message.tool_calls:
+                tool_calls_data = []
+                for tool_call in message.tool_calls:
+                    tool_calls_data.append({
+                        'id': tool_call.id,
+                        'type': tool_call.type,
+                        'function': {
+                            'name': tool_call.function.name,
+                            'arguments': tool_call.function.arguments
+                        }
+                    })
+                return {"type": "tool_calls", "data": tool_calls_data}
+            return {"type": "content", "data": message.content or ""}
+        return {"type": "content", "data": str(response)}
+
+    async def apply_llm_response(self, task, llm_response):
+        parsed_response = self.parse_llm_response(llm_response)
+        if parsed_response["type"] == "tool_calls":
+            for tool_call in parsed_response["data"]:
+                if tool_call["function"]["name"] == "write_to_file":
+                    args = json.loads(tool_call["function"]["arguments"])
+                    file_path = os.path.join(self.cwd, args["path"].strip())
+                    content = args["content"]
+                    if await self.file_exists(file_path):
+                        original_content = await self.read_file(file_path)
+                        file_diff = self.generate_diff(original_content, content, os.path.basename(file_path))
+                        # Interaction with user removed for automation context
+                        return await self.write_to_file(file_path, content, True)
+                    else:
+                        return await self.write_to_file(file_path, content)
+                elif tool_call["function"]["name"] == "execute_command":
+                    args = json.loads(tool_call["function"]["arguments"])
+                    command = args.get("command", "").strip()
+                    if command:
+                        return await self.execute_command(command)
+                    else:
+                        return False
+                elif tool_call["function"]["name"] == "read_file":
+                    args = json.loads(tool_call["function"]["arguments"])
+                    file_path = args.get("path", "").strip()
+                    if file_path:
+                        content = await self.read_file(os.path.join(self.cwd, file_path))
+                        return True if content is not None else False
+                    else:
+                        return False
+                elif tool_call["function"]["name"] == "tavily_web_search":
+                    args = json.loads(tool_call["function"]["arguments"])
+                    return await self.tavily_web_search(args.get("query"))
+                else:
+                    return False
+        return True
+
+    async def process_task(self, task: str):
+        llm_response = await acompletion(
+            model="gpt-4",
+            messages=[
+                {"role": "user", "content": task}
+            ],
+            tools=self.tools,
+            tool_choice="auto"
+        )
+        return await self.apply_llm_response(task, llm_response)
+
+async def main():
+    ai_coder = AICoder()
+    await ai_coder.process_task("Create a file called `hello.txt` with the content 'Hello, world!'")
+    await ai_coder.process_task("Edit the file called `hello.txt` and change the content to 'Hello again, world!'")
+    await ai_coder.process_task("Show me the current working directory")
+    await ai_coder.process_task("Read the contents of hello.txt")
+
+if __name__ == "__main__":
+    asyncio.run(main())