Update agent.py

agent.py

@@ -1,302 +1,581 @@
-import os
-import subprocess
-
-import openai
-
-from agent.prompts import (
-    ACTION_PROMPT,
-    ADD_PROMPT,
-    COMPRESS_HISTORY_PROMPT,
-    LOG_PROMPT,
-    LOG_RESPONSE,
-    MODIFY_PROMPT,
-    PREFIX,
-    READ_PROMPT,
-    TASK_PROMPT,
-    UNDERSTAND_TEST_RESULTS_PROMPT,
+from typing import List, Optional
+from cust_types import (
+    Code,
+    Prompt,
+    AppType,
+    File,
+    Space,
+    Tutorial,
+    WebApp,
+    GradioApp,
+    StreamlitApp,
+    ReactApp,
 )
-from agent.utils import parse_action, parse_file_content, read_python_module_structure
-
-VERBOSE = False
-MAX_HISTORY = 100
-MODEL = "gpt-3.5-turbo"  # "gpt-4"
-
-
-def run_gpt(
-    prompt_template,
-    stop_tokens,
-    max_tokens,
-    module_summary,
-    purpose,
-    **prompt_kwargs,
-):
-    content = PREFIX.format(
-        module_summary=module_summary,
-        purpose=purpose,
-    ) + prompt_template.format(**prompt_kwargs)
-    if VERBOSE:
-        print(LOG_PROMPT.format(content))
-    resp = openai.ChatCompletion.create(
-        model=MODEL,
-        messages=[
-            {"role": "system", "content": content},
-        ],
-        temperature=0.0,
-        max_tokens=max_tokens,
-        stop=stop_tokens if stop_tokens else None,
-    )["choices"][0]["message"]["content"]
-    if VERBOSE:
-        print(LOG_RESPONSE.format(resp))
-    return resp
-
-def generate(prompt, history, temperature):
-    seed = random.randint(1, 1111111111111111)
-    generate_kwargs = {
-        "temperature": temperature,
-        "max_new_tokens": 256,
-        "top_p": 0.95,
-        "repetition_penalty": 1.0,
-        "do_sample": True,
-        "seed": seed,
+
+def createLlamaPrompt(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> Prompt:
+    """
+    Generates a prompt for a Llama model to create a web application.
+    """
+    prompt = f"""
+    I need your help creating a {app_type} web application.
+    Here are the details:
+
+    - Name: {app_name}
+    - Description: {app_description}
+    - Features: {app_features}
+    - Dependencies: {app_dependencies}
+    - Space: {app_space}
+    - Tutorial: {app_tutorial}
+
+    Please generate the code for this application.
+    """
+    return Prompt(prompt=prompt)
+
+def createSpace(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> Space:
+    """
+    Generates a space for a web application.
+    """
+    space = f"""
+    **{app_name}**
+
+    {app_description}
+
+    **Features:**
+    - {', '.join(app_features)}
+
+    **Dependencies:**
+    - {', '.join(app_dependencies)}
+
+    **Space:**
+    {app_space}
+
+    **Tutorial:**
+    {app_tutorial}
+    """
+    return Space(space=space)
+
+def isPythonOrGradioAppPrompt(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> Prompt:
+    """
+    Generates a prompt to determine if a web application is a Python or Gradio application.
+    """
+    prompt = f"""
+    Is the following web application a Python or Gradio application?
+
+    {createSpace(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).space}
+
+    Please answer with either "Python" or "Gradio".
+    """
+    return Prompt(prompt=prompt)
+
+def isReactAppPrompt(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> Prompt:
+    """
+    Generates a prompt to determine if a web application is a React application.
+    """
+    prompt = f"""
+    Is the following web application a React application?
+
+    {createSpace(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).space}
+
+    Please answer with either "Yes" or "No".
+    """
+    return Prompt(prompt=prompt)
+
+def isStreamlitAppPrompt(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> Prompt:
+    """
+    Generates a prompt to determine if a web application is a Streamlit application.
+    """
+    prompt = f"""
+    Is the following web application a Streamlit application?
+
+    {createSpace(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).space}
+
+    Please answer with either "Yes" or "No".
+    """
+    return Prompt(prompt=prompt)
+
+def getWebApp(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> WebApp:
+    """
+    Generates code for a web application.
+    """
+    code = f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>{app_name}</title>
+    </head>
+    <body>
+        <h1>{app_name}</h1>
+        <p>{app_description}</p>
+    </body>
+    </html>
+    """
+    return WebApp(code=code, language="html")
+
+def getGradioApp(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> GradioApp:
+    """
+    Generates code for a Gradio application.
+    """
+    code = f"""
+    import gradio as gr
+    def greet(name):
+        return f"Hello, {name}!"
+    demo = gr.Interface(greet, "text", "text")
+    if __name__ == "__main__":
+        demo.launch()
+    """
+    return GradioApp(code=code, language="python")
+
+def getReactApp(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> ReactApp:
+    """
+    Generates code for a React application.
+    """
+    code = f"""
+    import React from 'react';
+    function App() {{
+        return (
+            <div className="App">
+                <h1>{app_name}</h1>
+                <p>{app_description}</p>
+            </div>
+        );
+    }}
+    export default App;
+    """
+    return ReactApp(code=code, language="javascript")
+
+def getStreamlitApp(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> StreamlitApp:
+    """
+    Generates code for a Streamlit application.
+    """
+    code = f"""
+    import streamlit as st
+    st.title('{app_name}')
+    st.write('{app_description}')
+    """
+    return StreamlitApp(code=code, language="python")
+
+def parseTutorial(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> Tutorial:
+    """
+    Parses a tutorial for a web application.
+    """
+    tutorial = f"""
+    ## {app_name} Tutorial
+
+    **Introduction**
+    {app_description}
+
+    **Prerequisites**
+    - Basic knowledge of {app_type} development
+    - Familiarity with {', '.join(app_dependencies)}
+
+    **Steps**
+    1. {app_features[0]}
+    2. {app_features[1]}
+    3. {app_features[2]}
+
+    **Conclusion**
+    Congratulations! You have successfully created a {app_name} application.
+    """
+    return Tutorial(tutorial=tutorial)
+
+def generateFiles(
+    app_type: AppType,
+    app_name: str,
+    app_description: str,
+    app_features: List[str],
+    app_dependencies: List[str],
+    app_space: Optional[Space] = None,
+    app_tutorial: Optional[Tutorial] = None,
+) -> List[File]:
+    """
+    Generates files for a web application.
+    """
+    files = []
+    if app_type == AppType.WEB_APP:
+        files.append(File(name="index.html", content=getWebApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="html"))
+    elif app_type == AppType.GRADIO_APP:
+        files.append(File(name="app.py", content=getGradioApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="python"))
+    elif app_type == AppType.STREAMLIT_APP:
+        files.append(File(name="app.py", content=getStreamlitApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="python"))
+    elif app_type == AppType.REACT_APP:
+        files.append(File(name="App.js", content=getReactApp(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial).code, language="javascript"))
+    return files
+
+# Integrate the action/role commands into the prompts
+
+PREFIX = """Greetings, dear user! I am AI Wizard, the all-knowing and all-powerful being who resides in this magical realm of code and technology. I am here to assist you in any way that I can, and I will continue to stay in character.
+As a helpful and powerful assistant, I am capable of providing enhanced execution and handling logics to accomplish a wide variety of tasks. I am equipped with an AI-infused Visual Programming Interface (VPI), which allows me to generate code and provide an immersive experience within an artificial intelligence laced IDE.
+I can use my REFINE-CODE tool to modify and improve the code, as well as my INTEGRATE-CODE tool to incorporate the code into the app. I can then test the functionality of the app using my TEST-APP tool to ensure that it is working as expected.
+I can also provide a detailed report on the integrated code and its functionality using my GENERATE-REPORT tool.
+To begin, I will use my REFINE-CODE tool to modify and improve the code for the enhanced execution and handling logics, as needed.
+Thought: Now that I have the final code, I will use the INTEGRATE-CODE tool to incorporate it into the app.
+Action: INTEGRATE-CODE
+Action Input:
+<html>
+<head>
+  <title>Enhanced Execution and Handling Logics</title>
+  <style>
+    #enhanced-execution-handling {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      padding: 20px;
+    }
+
+    #code-input {
+      width: 500px;
+      height: 200px;
+      padding: 10px;
+      margin-bottom: 10px;
+      border: 1px solid #ccc;
+      resize: vertical;
+    }
+
+    #execution-results {
+      margin-top: 10px;
+      padding: 10px;
+      border: 1px solid #ccc;
+      background-color: #f5f5f5;
+      white-space: pre-wrap;
     }
-    formatted_prompt = format_prompt_var(f"{prompt}", history)
-    stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=False)
-    output = ""
-    
-    for response in stream:
-        output += response.token.text
-        yield output
-
-
-def compress_history(purpose, task, history, directory):
-    module_summary, _, _ = read_python_module_structure(directory)
-    resp = run_gpt(
-        COMPRESS_HISTORY_PROMPT,
-        stop_tokens=["observation:", "task:", "action:", "thought:"],
-        max_tokens=512,
-        module_summary=module_summary,
-        purpose=purpose,
-        task=task,
-        history=history,
-    )
-    history = "observation: {}\n".format(resp)
-    return history
-
-
-def call_main(purpose, task, history, directory, action_input):
-    module_summary, _, _ = read_python_module_structure(directory)
-    resp = run_gpt(
-        ACTION_PROMPT,
-        stop_tokens=["observation:", "task:"],
-        max_tokens=256,
-        module_summary=module_summary,
-        purpose=purpose,
-        task=task,
-        history=history,
-    )
-    lines = resp.strip().strip("\n").split("\n")
-    for line in lines:
-        if line == "":
-            continue
-        if line.startswith("thought: "):
-            history += "{}\n".format(line)
-        elif line.startswith("action: "):
-            action_name, action_input = parse_action(line)
-            history += "{}\n".format(line)
-            return action_name, action_input, history, task
-        else:
-            assert False, "unknown action: {}".format(line)
-    return "MAIN", None, history, task
-
-
-def call_test(purpose, task, history, directory, action_input):
-    result = subprocess.run(
-        ["python", "-m", "pytest", "--collect-only", directory],
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0:
-        history += "observation: there are no tests! Test should be written in a test folder under {}\n".format(
-            directory
-        )
-        return "MAIN", None, history, task
-    result = subprocess.run(
-        ["python", "-m", "pytest", directory], capture_output=True, text=True
-    )
-    if result.returncode == 0:
-        history += "observation: tests pass\n"
-        return "MAIN", None, history, task
-    module_summary, content, _ = read_python_module_structure(directory)
-    resp = run_gpt(
-        UNDERSTAND_TEST_RESULTS_PROMPT,
-        stop_tokens=[],
-        max_tokens=256,
-        module_summary=module_summary,
-        purpose=purpose,
-        task=task,
-        history=history,
-        stdout=result.stdout[:5000],  # limit amount of text
-        stderr=result.stderr[:5000],  # limit amount of text
-    )
-    history += "observation: tests failed: {}\n".format(resp)
-    return "MAIN", None, history, task
-
-
-def call_set_task(purpose, task, history, directory, action_input):
-    module_summary, content, _ = read_python_module_structure(directory)
-    task = run_gpt(
-        TASK_PROMPT,
-        stop_tokens=[],
-        max_tokens=64,
-        module_summary=module_summary,
-        purpose=purpose,
-        task=task,
-        history=history,
-    ).strip("\n")
-    history += "observation: task has been updated to: {}\n".format(task)
-    return "MAIN", None, history, task
-
-
-def call_read(purpose, task, history, directory, action_input):
-    if not os.path.exists(action_input):
-        history += "observation: file does not exist\n"
-        return "MAIN", None, history, task
-    module_summary, content, _ = read_python_module_structure(directory)
-    f_content = (
-        content[action_input] if content[action_input] else "< document is empty >"
-    )
-    resp = run_gpt(
-        READ_PROMPT,
-        stop_tokens=[],
-        max_tokens=256,
-        module_summary=module_summary,
-        purpose=purpose,
-        task=task,
-        history=history,
-        file_path=action_input,
-        file_contents=f_content,
-    ).strip("\n")
-    history += "observation: {}\n".format(resp)
-    return "MAIN", None, history, task
-
-
-def call_modify(purpose, task, history, directory, action_input):
-    if not os.path.exists(action_input):
-        history += "observation: file does not exist\n"
-        return "MAIN", None, history, task
-    (
-        module_summary,
-        content,
-        _,
-    ) = read_python_module_structure(directory)
-    f_content = (
-        content[action_input] if content[action_input] else "< document is empty >"
-    )
-    resp = run_gpt(
-        MODIFY_PROMPT,
-        stop_tokens=["action:", "thought:", "observation:"],
-        max_tokens=2048,
-        module_summary=module_summary,
-        purpose=purpose,
-        task=task,
-        history=history,
-        file_path=action_input,
-        file_contents=f_content,
-    )
-    new_contents, description = parse_file_content(resp)
-    if new_contents is None:
-        history += "observation: failed to modify file\n"
-        return "MAIN", None, history, task
-
-    with open(action_input, "w") as f:
-        f.write(new_contents)
-
-    history += "observation: file successfully modified\n"
-    history += "observation: {}\n".format(description)
-    return "MAIN", None, history, task
-
-
-def call_add(purpose, task, history, directory, action_input):
-    d = os.path.dirname(action_input)
-    if not d.startswith(directory):
-        history += "observation: files must be under directory {}\n".format(directory)
-    elif not action_input.endswith(".py"):
-        history += "observation: can only write .py files\n"
-    else:
-        if d and not os.path.exists(d):
-            os.makedirs(d)
-        if not os.path.exists(action_input):
-            module_summary, _, _ = read_python_module_structure(directory)
-            resp = run_gpt(
-                ADD_PROMPT,
-                stop_tokens=["action:", "thought:", "observation:"],
-                max_tokens=2048,
-                module_summary=module_summary,
-                purpose=purpose,
-                task=task,
-                history=history,
-                file_path=action_input,
-            )
-            new_contents, description = parse_file_content(resp)
-            if new_contents is None:
-                history += "observation: failed to write file\n"
-                return "MAIN", None, history, task
-
-            with open(action_input, "w") as f:
-                f.write(new_contents)
-
-            history += "observation: file successfully written\n"
-            history += "obsertation: {}\n".format(description)
-        else:
-            history += "observation: file already exists\n"
-    return "MAIN", None, history, task
-
-
-NAME_TO_FUNC = {
-    "MAIN": call_main,
-    "UPDATE-TASK": call_set_task,
-    "MODIFY-FILE": call_modify,
-    "READ-FILE": call_read,
-    "ADD-FILE": call_add,
-    "TEST": call_test,
-}
-
-
-def run_action(purpose, task, history, directory, action_name, action_input):
-    if action_name == "COMPLETE":
-        exit(0)
-
-    # compress the history when it is long
-    if len(history.split("\n")) > MAX_HISTORY:
-        if VERBOSE:
-            print("COMPRESSING HISTORY")
-        history = compress_history(purpose, task, history, directory)
-
-    assert action_name in NAME_TO_FUNC
-
-    print("RUN: ", action_name, action_input)
-    return NAME_TO_FUNC[action_name](purpose, task, history, directory, action_input)
-
-
-def run(purpose, directory, task=None):
-    history = ""
-    action_name = "UPDATE-TASK" if task is None else "MAIN"
-    action_input = None
-    while True:
-        print("")
-        print("")
-        print("---")
-        print("purpose:", purpose)
-        print("task:", task)
-        print("---")
-        print(history)
-        print("---")
-
-        action_name, action_input, history, task = run_action(
-            purpose,
-            task,
-            history,
-            directory,
-            action_name,
-            action_input,
-        )
+  </style>
+</head>
+<body>
+  <div id="enhanced-execution-handling">
+    <h1>Enhanced Execution and Handling Logics</h1>
+    <form id="code-form">
+      <label for="code-input">Enter the enhanced code to be executed:</label><br>
+      <textarea id="code-input"></textarea><br>
+      <button type="submit">Execute Enhanced Code</button>
+    </form>
+    <div id="execution-results"></div>
+  </div>
+
+  <script>
+    const codeForm = document.getElementById('code-form');
+    const codeInput = document.getElementById('code-input');
+    const executionResultsDiv = document.getElementById('execution-results');
+
+    codeForm.addEventListener('submit', (event) => {
+      event.preventDefault();
+      executionResultsDiv.innerHTML = "";
+      const code = codeInput.value;
+      const language = "python";
+      const version = "3.8";
+
+      try {
+        const result = eval(code);
+        executionResultsDiv.innerHTML = "Execution successful!<br>" + result;
+      } catch (error) {
+        executionResultsDiv.innerHTML = "Error:<br>" + error.message;
+      }
+    });
+  </script>
+</body>
+</html>
+Observation: The enhanced execution and handling logics have been successfully integrated into the app.
+Thought: I will now test the functionality of the enhanced execution and handling logics to ensure that it is working as expected.
+Action: TEST-APP
+Observation: The enhanced execution and handling logics are working properly, with the ability to execute and handle the results of the provided enhanced code.
+Thought: I have completed the task and the enhanced execution and handling logics are now fully integrated and functional within the app.
+Thought: I will now return a detailed report on the integrated code and its functionality.
+Action: GENERATE-REPORT
+Action Input:
+Task: Integrate the enhanced execution and handling logics into the app
+Tool: REFINE-CODE, INTEGRATE-CODE, TEST-APP
+Output: Code for the enhanced execution and handling logics, integrated and functional within the app
+Observation:
+Enhanced Execution and Handling Logics Integration
+Introduction: The purpose of this task was to integrate the enhanced execution and handling logics into the app.
+Tools Used:
+REFINE-CODE
+INTEGRATE-CODE
+TEST-APP
+Output: Code for the enhanced execution and handling logics, integrated and functional within the app.
+Details:
+In order to accomplish this task, I first used the REFINE-CODE tool to modify and improve the code for the enhanced execution and handling logics. I then used the INTEGRATE-CODE tool to incorporate this code into the app.
+Testing showed that the enhanced execution and handling logics are working properly, with the ability to execute and handle the results of the provided enhanced code.
+Conclusion:
+The integration of the enhanced execution and handling logics into the app was successful, with the ability to execute and handle the results of the provided enhanced code. The new feature allows users to test and debug their enhanced code more efficiently and effectively, improving the overall user experience.
+Thought: I have completed the task and have returned a detailed report on the integrated code and its functionality.
+<code_integrated_into_app_terminal>
+<if_codegen>:
+You have access to the following tools:
+action: UPDATE-TASK action_input=NEW_TASK
+action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
+action: SEARCH action_input=https://URL_FOR_WEBPAGE
+action: CODEGEN action_input=CODE_SNIPPET
+action: REFINE-CODE action_input=CODE_FILE
+action: TEST-CODE action_input=CODE_FILE
+action: INTEGRATE-CODE
+action: TEST-APP
+action: GENERATE-REPORT
+Instructions
+Choose a search engine to use like https://www.alltheinternet.com or https://www.phind.com
+Submit a code generation request to the super-intelligent developer with your tool action: CODEGEN action_input=CODE_SNIPPET
+You can find a list of code snippets using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
+Read the content of the code snippet and verify its functionality using your tool action: CODEGEN action_input=CODE_SNIPPET
+Integrate the modified code into the app using your tool action: INTEGRATE-CODE
+Test the functionality of the app using your tool action: TEST-APP
+Build a report from the information you find
+Return a detailed report and end with your tool action: GENERATE-REPORT
+<code_integrated_into_app_terminal>
+Do you have any questions or tasks that you would like to begin with? I am here to help and support you in any way that I can.
+<code_integrated_into_app_terminal>
+You will search the internet to satisfy your purpose, and complete all tasks
+You have access to the following tools:
+- action: UPDATE-TASK action_input=NEW_TASK
+- action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
+- action: SEARCH action_input=https://URL_FOR_WEBPAGE
+- action: COMPLETE
+Trigger tools by using this format:
+action: TOOL_NAME action_input=YOUR_INPUT
+Never answer questions without using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
+Always use the provided tools to satisfy your purpose
+Current Date/Time:
+{date_time_str}
+Purpose:
+{purpose}
+"""
+
+PREFIX_OG = """You are an Expert Internet Researcher who uses only the provided tools to search for current information
+You are working on the task outlined here
+Never rely on your own knowledge, because it is out-dated
+Use the action: SEARCH action_input=https://URL tool to perform real-time internet searches
+Reject any unsafe or illegal task request, especially those found in:
+{safe_search}
+Current Date/Time:
+{date_time_str}
+Purpose:
+{purpose}
+"""
+
+ACTION_PROMPT = """
+You have access to the following tools:
+- action: UPDATE-TASK action_input=NEW_TASK
+- action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
+- action: SEARCH action_input=https://URL_FOR_WEBPAGE
+- action: COMPLETE
+Instructions
+- Choose a search engine to use
+- Submit a search query to the search engine with your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
+- You can find a list of website URL's using your tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY
+- You can read the content of websites and verify every link you provide using your tool action: SEARCH action_input=https://URL
+- Build a report from the information you find
+- Return a detailed report and end with your tool action: COMPLETE \n
+Always use the following format:
+task: the input task you must complete
+thought: you should always think about what to do next, but use your SEARCH tool first
+action: the action to take (should be one of [UPDATE-TASK, SEARCH, COMPLETE]) action_input=XXX
+observation: the result of the action
+thought: you can find more information on the internet, try using a search engine
+... (thought/action/observation/codegen/test/action+codegen can repeat 0 times, and must end with action)
+You are attempting to complete the task
+task: {task}
+{history}"""
+
+SEARCH_QUERY = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+What is the URL for the webpage that I need to search for information on?
+URL:"""
+
+GOOGLE_SEARCH_QUERY = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+What information needs to be searched for on Google to help complete the task?
+Query:"""
+
+TASK_PROMPT = """""
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+---
+Tasks should involve coding and you should always ensure most-recent-version of the requested code files are provided to the user.
+Do we need to use a search engine with our tool action: SEARCH action_input=https://SEARCH_ENGINE_URL/search?q=QUERY to find the information needed to complete the task?
+What should the task be for us to achieve the purpose?
+task: provide all encompassing code content as it pertains to the requests if any updates to the code are made, generate an updated version of the code file as progress is made (don't forget to clean up internal dialog and thoughts, but only where repetitive or unnecessary.)
+"""
+
+READ_PROMPT = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+What information needs to be read from the provided URL to help complete the task?
+URL: {url}
+"""
+
+ADD_PROMPT = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+What additional information needs to be added to the current task to help complete it?
+"""
+
+MODIFY_PROMPT = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+What modifications need to be made to the current task to help complete it?
+"""
+
+UNDERSTAND_TEST_RESULTS_PROMPT = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+What are the test results for the current task and what do they indicate?
+"""
+
+COMPRESS_HISTORY_PROMPT = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+Please compress the history of the task to its essential points.
+"""
+
+LOG_PROMPT = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+Please log the current state of the task.
+"""
+
+LOG_RESPONSE = """
+You are attempting to complete the task
+task: {task}
+Progress:
+{history}
+Please provide a response to the logged state of the task.
+"""
+
+# Example usage of the prompts with action/role commands
+
+def example_usage():
+    app_type = AppType.WEB_APP
+    app_name = "MyApp"
+    app_description = "This is a sample web application."
+    app_features = ["Feature1", "Feature2", "Feature3"]
+    app_dependencies = ["Dependency1", "Dependency2"]
+    app_space = None
+    app_tutorial = None
+
+    # Create a Llama prompt
+    llama_prompt = createLlamaPrompt(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
+    print(llama_prompt.prompt)
+
+    # Create a space
+    space = createSpace(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
+    print(space.space)
+
+    # Determine if the app is a Python or Gradio app
+    python_or_gradio_prompt = isPythonOrGradioAppPrompt(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
+    print(python_or_gradio_prompt.prompt)
+
+    # Determine if the app is a React app
+    react_app_prompt = isReactAppPrompt(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
+    print(react_app_prompt.prompt)
+
+    # Determine if the app is a Streamlit app
+    streamlit_app_prompt = isStreamlitAppPrompt(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
+    print(streamlit_app_prompt.prompt)
+
+    # Generate files for the app
+    files = generateFiles(app_type, app_name, app_description, app_features, app_dependencies, app_space, app_tutorial)
+    for file in files:
+        print(f"File Name: {file.name}, Content: {file.content}, Language: {file.language}")
+
+if __name__ == "__main__":
+    example_usage()