Привет, сделай простого и удобного бота для того, чтобы он мог выполнять инструкции программиста по созданию файлов, указанию их содержимого, а также получению информации о текущей файловой структуры проекта, используя модель gpt-4o-mini.
Я уже реализовывал, почти, что-то подобное, вот моя реализация:

project_structure_manager.py:
```py
import os
from pathlib import Path


class ProjectStructureManagement:
    def __init__(self):
        self.current_project_path = "test_project"

    def process_path(self, path):
        first = path.split("/")[0]
        print(f"== first = {first}")
        print(f"== current_project_path = {self.current_project_path}")
        if first == self.current_project_path:
            return path

    def create_new_project(self, project_name):
        project_path = os.path.join(os.getcwd(), project_name)
        os.makedirs(project_path, exist_ok=True)
        self.current_project_path = project_path
        return project_path

    def get_project_structure(self):
        if not self.current_project_path:
            return "No project has been created or set."

        root_dir = self.current_project_path
        root_dir_display = os.path.basename(root_dir)

        def walk_dir(dir_path, prefix=""):
            contents = sorted(os.listdir(dir_path))
            paths = [os.path.join(dir_path, p) for p in contents]
            dirs = [p for p in paths if os.path.isdir(p)]
            files = [p for p in paths if os.path.isfile(p)]

            lines = []
            for d in dirs:
                lines.append(f"{prefix}├── {os.path.basename(d)}/")
                lines.extend(walk_dir(d, prefix + "│   "))
            for f in files:
                if f != files[-1]:
                    lines.append(f"{prefix}├── {os.path.basename(f)}")
                else:
                    lines.append(f"{prefix}└── {os.path.basename(f)}")
            return lines

        return "\n".join([root_dir_display + "/"] + walk_dir(root_dir))

    def read_file(self, file_path):
        file_path = self.process_path(file_path)
        if not os.path.exists(file_path):
            return f"File not found: {file_path}"
        try:
            with open(file_path, 'r', encoding='utf-8') as file:
                return file.read()
        except Exception as e:
            return f"Error reading file: {str(e)}"

    def update_file(self, file_path, content):
        full_path = self.process_path(file_path)
        try:
            with open(full_path, 'w', encoding='utf-8') as file:
                file.write(content)
            return f"File updated successfully: {file_path}"
        except Exception as e:
            return f"Error updating file: {str(e)}"

    def rename_file(self, old_path, new_name):
        old_full_path = self.process_path(old_path)
        new_full_path = os.path.join(os.path.dirname(old_full_path), new_name)
        try:
            os.rename(old_full_path, new_full_path)
            return f"File renamed successfully from {old_path} to {new_name}"
        except Exception as e:
            return f"Error renaming file: {str(e)}"

    def create_file(self, path, content):
        if not self.current_project_path:
            return "No project has been created or set."

        full_file_path = self.process_path(path)

        try:
            # Создаем директорию, если она не существует
            #os.makedirs(path, exist_ok=True)

            # Создаем файл и записываем в него содержимое
            with open(full_file_path, 'w', encoding='utf-8') as file:
                file.write(content)

            return f"File created successfully: {path}"
        except Exception as e:
            return f"Error creating file: {str(e)}"
```

ai_tools.py
```py

# Инструменты начальника
AI_Boss_tools = [
    {
        "type": "function",
        "function": {
            "name": "send_task_to_developer",
            "description": "Отправляет запрос разработчику",
            "parameters": {
                "type": "object",
                "properties": {
                    "technical_task": {
                        "type": "string",
                        "description": "Профессиональное техническое задание"
                    },
                    "note": {
                        "type": "string",
                        # "enum": ["Celsius", "Fahrenheit"],
                        "description": "Примечание к техническому заданию(человеческое общение)"
                    }
                },
                "required": ["technical_task", "note"]
            }
        }
    },
]

# Инструменты разработчика
AIEngineer_tools = [
    {
        "type": "function",
        "function": {
            "name": "get_project_structure",
            "description": "Возвращает файловую структуру проекта",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": []
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Возвращает содержимое файла",
            "parameters": {
                "type": "object",
                "properties": {
                    "file_path": {
                        "type": "string",
                        "description": "Локальный путь к файлу в проекте(Например, project/main.py)"
                    }
                },
                "required": ["file_path"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "update_file",
            "description": "Обновляет содержимое файла",
            "parameters": {
                "type": "object",
                "properties": {
                    "file_path": {
                        "type": "string",
                        "description": "Локальный путь к файлу в проекте(Например, project/main.py)"
                    },
                    "content": {
                        "type": "string",
                        "description": "Новое содержимое файла(программный код)"
                    }
                },
                "required": ["file_path", "content"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "rename_file",
            "description": "Переименовывает файл",
            "parameters": {
                "type": "object",
                "properties": {
                    "old_path": {
                        "type": "string",
                        "description": "Локальный путь к файлу в проекте(Например, project/main.py)"
                    },
                    "new_name": {
                        "type": "string",
                        "description": "Новое имя файла"
                    }
                },
                "required": ["old_path", "new_name"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "create_file",
            "description": "Создает новый файл в заданной директории с заданным содержимым",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "Локальный путь к файлу в проекте(Например, project/main.py)"
                    },
                    "content": {
                        "type": "string",
                        "description": "Содержимое(программный код)"
                    }
                },
                "required": ["path", "content"]
            }
        }
    }
]
```

main.py:
```py
import json
import httpx
from openai import OpenAI
from V2.project_structure_management import ProjectStructureManagement
from  V2.ai_tools import AI_Boss_tools, AIEngineer_tools

# Для консольной отладки
def PrintConsoleAI(role, message):
    print(f"\n{role}:\n```\n{message}\n```\n")

class AIEngineer:
    def __init__(self, OPENAI_API_KEY, proxy=None):
        self.client = self.loadOpenAI_Client(OPENAI_API_KEY, proxy)
        self.BOSS_PROMPT, self.PROGRAMMER_PROMPT = self.getSystemPrompts(
            "../BOSS_PROMPT2.txt",
            "../PROGRAMMER_PROMPT2.txt"
        )
        self.AI_Boss_messages = self.initMessages(self.BOSS_PROMPT)
        self.project_manager = ProjectStructureManagement()

    def loadOpenAI_Client(self, OPENAI_API_KEY, proxy):
        httpx_Client_proxy = None
        if proxy:
            # Разбиваем строку с прокси на части
            proxy_parts = proxy.split(":")
            proxy_host = proxy_parts[1][2:]  # Убираем "//" из начала хоста
            proxy_port = int(proxy_parts[2])
            proxy_user = proxy_parts[3]
            proxy_password = proxy_parts[4]

            httpx_Client_proxy = httpx.Client(
                proxies="http://" + proxy_user + ":" + proxy_password + "@" + proxy_host + ":" + str(
                    proxy_port),
                verify=False  # Добавляем проверку сертификата
            )
        # Создаем HTTP-клиент с прокси
        client = OpenAI(
            api_key=OPENAI_API_KEY,
            http_client=httpx_Client_proxy
        )
        return client

    def getSystemPrompts(self, BOSS_PROMPT_FILE, PROGRAMMER_PROMPT_FILE):
        with open(BOSS_PROMPT_FILE, 'r', encoding='utf-8') as file:
            BOSS_PROMPT = file.read()
        with open(PROGRAMMER_PROMPT_FILE, 'r', encoding='utf-8') as file:
            PROGRAMMER_PROMPT = file.read()
        return BOSS_PROMPT, PROGRAMMER_PROMPT

    def initMessages(self, SystemPrompt):
         return [{"role": "system", "content": SystemPrompt}]

    def ai_mind_generator(self, tools, role, messages):
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        response_message = response.choices[0].message
        messages.append(response_message)
        print(f"messages after response: {messages}\n")

        yield {"type": "message", "role": role, "message": response_message.content}

        # Обработка вызовов функций
        tool_calls = response_message.tool_calls
        if tool_calls:
            for tool_call in tool_calls:
                tool_call_id = tool_call.id
                tool_function_name = tool_call.function.name

                _arguments = json.loads(tool_call.function.arguments)

                yield {"type": "tool_call", "role": role, "tool_function_name": tool_function_name, "arguments": _arguments}

                function_result = ""
                if tool_function_name == 'send_task_to_developer':
                    tool_technical_task_string = _arguments['technical_task']
                    tool_note_string = _arguments['note']

                    engineer_messages = self.initMessages(self.PROGRAMMER_PROMPT)
                    boss_to_engineer_message = f"Техническое задание:\n```{tool_technical_task_string}```\n\nДополнительное пояснение:\n```{tool_note_string}```"
                    engineer_messages.append({"role": "user", "content": boss_to_engineer_message})

                    developer_response_message = f""
                    # Отправляем запрос разработчику
                    for event in self.ai_mind_generator(AIEngineer_tools, "DEVELOPER", engineer_messages):
                        # Получаем ответы от разработчика
                        if event:
                            if event["type"] == "message":
                                yield {"type": "message", "role": "DEVELOPER", "message": event["message"]}  # Это для отчетности в интерфейсе, никуда не идет.
                                developer_response_message += f'{event["message"]}\n'
                            elif event["type"] == "tool_call":
                                yield {"type": "tool_call", "role": "DEVELOPER", "tool_function_name": event["tool_function_name"], "arguments": event["arguments"]}  # Это для отчетности в интерфейсе, никуда не идет.
                                if event["tool_function_name"] == "get_project_structure":
                                    developer_response_message += f'(System: Разработчик получает файловую структуру проекта)\n'
                                elif event["tool_function_name"] == "read_file":
                                    developer_response_message += f'(System: Разработчик читает файл "{event["arguments"]["file_path"]}")\n'
                                elif event["tool_function_name"] == "update_file":
                                    developer_response_message += f'(System: Разработчик обновляет файл "{event["arguments"]["file_path"]}")\n'
                                elif event["tool_function_name"] == "rename_file":
                                    developer_response_message += f'(System: Разработчик переименовывает файл "{event["arguments"]["old_path"]}")\n'
                                elif event["tool_function_name"] == "create_file":
                                    developer_response_message += f'(System: Разработчик создает файл "{event["arguments"]["path"]}")\n'

                    # Получаем ответ разработчика своему боссу и добавляем его
                    print(f"developer_response_message = ```{developer_response_message}```\n")
                    function_result = developer_response_message
                elif tool_function_name == "get_project_structure":
                    function_result = self.project_manager.get_project_structure()
                elif tool_function_name == "read_file":
                    function_result = self.project_manager.read_file(_arguments["file_path"])
                elif tool_function_name == "update_file":
                    function_result = self.project_manager.update_file(_arguments["file_path"], _arguments["content"])
                elif tool_function_name == "rename_file":
                    function_result = self.project_manager.rename_file(_arguments["old_path"], _arguments["new_name"])
                elif tool_function_name == "create_file":
                    function_result = self.project_manager.create_file(_arguments["path"], _arguments["content"])
                else:
                    print(f"Error: function {tool_function_name} does not exist")

                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call_id,
                    "name": tool_function_name,
                    "content": function_result
                })

            # Все tools_calls модели обработаны и нужно вернуть ей результат через эту же функцию в рекурсии
            for event in self.ai_mind_generator(tools, role, messages):
                yield event
        else:
            print(f"!! {role} has no tool calls! Даааа")

    def ask_response(self, text):
        print(f"ask_response")
        # Общение клиента с начальником разработчиков
        self.AI_Boss_messages.append({"role": "user", "content": text})
        print(f"self.AI_Boss_messages = {self.AI_Boss_messages}")

        for event in self.ai_mind_generator(AI_Boss_tools, "AI_BOSS", self.AI_Boss_messages):
            print(f"RECEIVED EVENT: {event}")
            if event:
                if event["type"] == "message":
                    role = event["role"]
                    message = event["message"]
                    PrintConsoleAI(role, message)
                elif event["type"] == "tool_call":
                    role = event["role"]
                    tool_function_name = event["tool_function_name"]
                    arguments = event["arguments"]
                    print(f"RECEIVED TOOL CALL by {role}, tool_function_name: {tool_function_name}, arguments: {arguments}")

        print("FULL DONE!!!!!!!!!!!")

myAIEngineer = AIEngineer("<TRUFFLEHOG_REDACTED_OPENAI>", "http://45.127.248.127:5128:ygjjobkd:j4kss27qaco0")

myAIEngineer.ask_response("Разработай мне автокликер на python с pyqt5. Не спрашивай ничего больше, просто приведи мне проект. Спасибо!")
```

Сделай так, чтобы бот умел делать все, что и этот с файлами, отдавал также такой же фитбек через генератор.
Используй только `AIEngineer_tools`, остальное - лишнее.

Я хочу, чтобы он мог получить большую инструкцию того, что ему делать, после чего выполнял бы функции для воспроизведения этого.

Каждый приведенный код уже рабочий, по этому основывайся на нем.

Сделай лучшую реализацию того, что я прошу.

Также, напиши полноценный системный промпт для модели на английском, чтобы она понимала, что от нее надо.
Также, перепиши описание и название функций, чтобы они были на английском, т.к. модель его лучше понимает.

Приведи точно такую же реализацию с классами, что и сейчас в main.

Спасибо!