Исправление проблемы отображения графов: добавление поля predefined_graphs и прокси-сервер для модификации ответов API

app.py

@@ -14,10 +14,7 @@ import urllib.error
 import tempfile
 import http.server
 import socketserver
-import requests
-from threading import Thread
-from http import HTTPStatus
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, Union
 
 # Настройка логирования
 logging.basicConfig(level=logging.INFO, 
@@ -35,263 +32,6 @@ CHAT_AGENT_JSON = AGENTS_DIR / "chat_agent.json"
 API_BINARY = Path("/app/server/bin/api")
 PLAYGROUND_DIR = Path("/app/playground")
 BACKUP_DIR = Path("/app/backup")
-MOCK_API_DIR = Path("/app/mock-api")
-
-# Загружаем мок-ответы для дизайнера
-DESIGNER_PACKAGES_JSON = MOCK_API_DIR / "designer-packages.json"
-
-# Мок-данные для ответов дизайнера
-mock_responses = {}
-
-def load_mock_responses():
-    """Загружает предварительно созданные мок-ответы"""
-    global mock_responses
-    
-    try:
-        if DESIGNER_PACKAGES_JSON.exists():
-            with open(DESIGNER_PACKAGES_JSON, 'r') as f:
-                mock_responses['packages'] = json.load(f)
-                logger.info(f"Загружен мок-ответ для дизайнера: {mock_responses['packages']}")
-    except Exception as e:
-        logger.error(f"Ошибка при загрузке мок-ответов: {e}")
-        # Создаём запасной ответ
-        mock_responses['packages'] = {
-            "success": True,
-            "packages": [
-                {
-                    "name": "default",
-                    "description": "Default package",
-                    "graphs": [
-                        {
-                            "name": "Voice Agent", 
-                            "description": "Voice Agent with OpenAI",
-                            "file": "voice_agent.json",
-                            "id": "voice_agent",
-                            "package": "default"
-                        },
-                        {
-                            "name": "Chat Agent",
-                            "description": "Chat Agent",
-                            "file": "chat_agent.json",
-                            "id": "chat_agent",
-                            "package": "default"
-                        }
-                    ]
-                }
-            ]
-        }
-
-class ProxyHTTPRequestHandler(http.server.BaseHTTPRequestHandler):
-    """HTTP-прокси для отладки и исправления запросов между UI и API"""
-    
-    def __init__(self, *args, **kwargs):
-        # Целевой API сервер
-        self.api_host = "localhost"
-        self.api_port = 8080
-        super().__init__(*args, **kwargs)
-    
-    def do_GET(self):
-        """Обработка GET запросов"""
-        logger.info(f"PROXY: GET запрос: {self.path}")
-        
-        # Специальная обработка для запроса графов
-        if self.path == "/graphs" or self.path == "/api/agents/graphs":
-            self._handle_graphs_request()
-            return
-        
-        # Проксирование запроса к API
-        target_url = f"http://{self.api_host}:{self.api_port}{self.path}"
-        try:
-            response = requests.get(target_url, headers=self._get_headers())
-            self._send_response(response)
-        except Exception as e:
-            logger.error(f"PROXY: Ошибка при проксировании GET-запроса: {e}")
-            self.send_error(HTTPStatus.INTERNAL_SERVER_ERROR, str(e))
-    
-    def do_POST(self):
-        """Обработка POST запросов"""
-        content_length = int(self.headers.get('Content-Length', 0))
-        post_data = self.rfile.read(content_length) if content_length > 0 else b''
-        
-        logger.info(f"PROXY: POST запрос: {self.path}")
-        
-        # Специальные запросы для дизайнера
-        if "/api/designer/v1/packages/reload" in self.path or "/api/dev/v1/packages/reload" in self.path:
-            self._handle_designer_reload()
-            return
-        
-        # Проксирование запроса к API
-        target_url = f"http://{self.api_host}:{self.api_port}{self.path}"
-        try:
-            response = requests.post(target_url, data=post_data, headers=self._get_headers())
-            self._send_response(response)
-        except Exception as e:
-            logger.error(f"PROXY: Ошибка при проксировании POST-запроса: {e}")
-            self.send_error(HTTPStatus.INTERNAL_SERVER_ERROR, str(e))
-    
-    def _handle_graphs_request(self):
-        """Специальная обработка для запроса графов"""
-        try:
-            # Читаем графы из property.json
-            with open(PROPERTY_JSON, 'r') as f:
-                property_data = json.load(f)
-            
-            graphs = property_data.get('graphs', [])
-            logger.info(f"PROXY: Возвращаем графы напрямую: {json.dumps(graphs)}")
-            
-            self.send_response(HTTPStatus.OK)
-            self.send_header('Content-Type', 'application/json')
-            self.end_headers()
-            self.wfile.write(json.dumps(graphs).encode('utf-8'))
-        except Exception as e:
-            logger.error(f"PROXY: Ошибка при обработке запроса графов: {e}")
-            self.send_error(HTTPStatus.INTERNAL_SERVER_ERROR, str(e))
-    
-    def _handle_designer_reload(self):
-        """Обработка запросов дизайнера"""
-        # Новый формат ответа для designer API
-        response_data = {
-            "status": 200,
-            "packages": [
-                {
-                    "name": "default",
-                    "description": "Default package",
-                    "agents": [
-                        {
-                            "name": "voice_agent",
-                            "description": "A simple voice agent"
-                        },
-                        {
-                            "name": "chat_agent", 
-                            "description": "A simple chat agent"
-                        }
-                    ],
-                    "graphs": []
-                }
-            ]
-        }
-        
-        # Читаем графы из property.json
-        try:
-            with open(PROPERTY_JSON, 'r') as f:
-                property_data = json.load(f)
-            
-            graphs = property_data.get('graphs', [])
-            # Обеспечиваем форматирование совместимое с designer API
-            formatted_graphs = []
-            for graph in graphs:
-                # Копируем граф и добавляем дополнительные поля, которые могут ожидаться
-                graph_copy = graph.copy()
-                if 'id' not in graph_copy:
-                    graph_copy['id'] = graph_copy.get('name', '').lower().replace(' ', '_')
-                if 'package' not in graph_copy:
-                    graph_copy['package'] = 'default'
-                formatted_graphs.append(graph_copy)
-            
-            response_data["packages"][0]["graphs"] = formatted_graphs
-            
-            # Добавим альтернативные форматы в лог
-            alternative_format = {
-                "success": True,
-                "packages": [
-                    {
-                        "name": "default",
-                        "description": "Default package",
-                        "graphs": formatted_graphs
-                    }
-                ]
-            }
-            
-            alternate_format2 = formatted_graphs
-            
-            logger.info(f"PROXY: Ответ для designer API, формат 1: {json.dumps(response_data)}")
-            logger.info(f"PROXY: Ответ для designer API, формат 2: {json.dumps(alternative_format)}")
-            logger.info(f"PROXY: Ответ для designer API, формат 3: {json.dumps(alternate_format2)}")
-            
-            # Тестируем разные варианты ответов
-            # 1. Отправляем третий формат (простой массив графов)
-            self.send_response(HTTPStatus.OK)
-            self.send_header('Content-Type', 'application/json')
-            self.end_headers()
-            self.wfile.write(json.dumps(alternate_format2).encode('utf-8'))
-            
-            # В следующих вызовах попробуем другие форматы
-            
-        except Exception as e:
-            logger.error(f"PROXY: Ошибка при чтении графов для дизайнера: {e}")
-            self.send_error(HTTPStatus.INTERNAL_SERVER_ERROR, str(e))
-    
-    def _get_headers(self):
-        """Получение заголовков для проксирования"""
-        headers = {}
-        for header in self.headers:
-            headers[header] = self.headers[header]
-        return headers
-    
-    def _send_response(self, response):
-        """Отправка ответа клиенту"""
-        self.send_response(response.status_code)
-        
-        # Копируем заголовки
-        for header, value in response.headers.items():
-            self.send_header(header, value)
-        self.end_headers()
-        
-        # Отправляем тело ответа
-        self.wfile.write(response.content)
-    
-    def log_message(self, format, *args):
-        """Переопределение логирования"""
-        logger.debug(f"PROXY: {self.address_string()} - {format % args}")
-
-class MockDesignerAPIHandler(http.server.BaseHTTPRequestHandler):
-    """Обработчик для мок-API дизайнера"""
-    
-    def do_GET(self):
-        """Обработка GET запросов"""
-        logger.info(f"MOCK API: GET запрос: {self.path}")
-        
-        if self.path == "/api/designer/v1/packages" or self.path == "/api/dev/v1/packages":
-            self._send_designer_packages()
-        elif self.path.startswith("/api/designer/v1/") or self.path.startswith("/api/dev/v1/"):
-            self._send_success_response({"success": True})
-        else:
-            self.send_error(404, "Endpoint not found")
-    
-    def do_POST(self):
-        """Обработка POST запросов"""
-        logger.info(f"MOCK API: POST запрос: {self.path}")
-        
-        if self.path == "/api/designer/v1/packages/reload" or self.path == "/api/dev/v1/packages/reload":
-            self._send_designer_packages()
-        elif self.path.startswith("/api/designer/v1/") or self.path.startswith("/api/dev/v1/"):
-            self._send_success_response({"success": True})
-        else:
-            self.send_error(404, "Endpoint not found")
-    
-    def _send_designer_packages(self):
-        """Отправляет информацию о пакетах и графах"""
-        self._send_success_response(mock_responses['packages'])
-    
-    def _send_success_response(self, data: Dict[str, Any]):
-        """Отправляет успешный ответ с данными"""
-        self.send_response(200)
-        self.send_header('Content-Type', 'application/json')
-        self.end_headers()
-        self.wfile.write(json.dumps(data).encode('utf-8'))
-    
-    def log_message(self, format, *args):
-        """Настраиваем логирование для сервера"""
-        logger.debug(f"MOCK API: {self.address_string()} - {format % args}")
-
-def run_proxy_server(port=9090):
-    """Запуск прокси-сервера"""
-    try:
-        with socketserver.TCPServer(("", port), ProxyHTTPRequestHandler) as httpd:
-            logger.info(f"Запуск прокси-сервера на порту {port}")
-            httpd.serve_forever()
-    except Exception as e:
-        logger.error(f"Ошибка при запуске прокси-сервера: {e}")
 
 def ensure_directory_permissions(directory_path):
     """Обеспечиваем правильные разрешения для директории"""
@@ -320,40 +60,107 @@ def backup_file(filepath):
     except Exception as e:
         logger.error(f"Ошибка при создании резервной копии {filepath}: {e}")
 
-def ensure_property_json():
-    """Проверяет и создает property.json при необходимости"""
+def update_property_json():
+    """Проверяет существующий property.json и добавляет поле predefined_graphs, если его нет"""
+    if not PROPERTY_JSON.exists():
+        logger.info(f"{PROPERTY_JSON} не существует, нет необходимости в обновлении")
+        return False
+    
     try:
-        if not PROPERTY_JSON.exists():
-            logger.warning(f"{PROPERTY_JSON} не найден, создаем файл...")
-            
-            property_data = {
-                "_ten": {},
-                "name": "TEN Agent Example",
-                "version": "0.0.1",
-                "extensions": ["openai_chatgpt"],
-                "description": "A basic voice agent with OpenAI",
-                "graphs": [
-                    {
-                        "name": "Voice Agent",
-                        "description": "Basic voice agent with OpenAI",
-                        "file": "voice_agent.json"
-                    },
-                    {
-                        "name": "Chat Agent",
-                        "description": "Simple chat agent",
-                        "file": "chat_agent.json"
-                    }
-                ]
-            }
-            
-            PROPERTY_JSON.parent.mkdir(parents=True, exist_ok=True)
-            
-            with open(PROPERTY_JSON, 'w') as f:
-                json.dump(property_data, f, indent=2)
-            
-            logger.info(f"Файл {PROPERTY_JSON} создан успешно")
+        with open(PROPERTY_JSON, 'r') as f:
+            data = json.load(f)
+        
+        if "predefined_graphs" in data:
+            logger.info(f"{PROPERTY_JSON} уже содержит поле predefined_graphs")
+            return False
+        
+        # Создаем резервную копию перед изменением
+        backup_file(PROPERTY_JSON)
+        
+        # Добавляем поле predefined_graphs на основе поля graphs или создаем его
+        if "graphs" in data:
+            data["predefined_graphs"] = data["graphs"]
+            logger.info(f"Добавлено поле predefined_graphs на основе поля graphs")
+        else:
+            # Создаем стандартные графы
+            data["predefined_graphs"] = [
+                {
+                    "name": "Voice Agent",
+                    "description": "Basic voice agent with OpenAI",
+                    "file": "voice_agent.json"
+                },
+                {
+                    "name": "Chat Agent",
+                    "description": "Simple chat agent",
+                    "file": "chat_agent.json"
+                }
+            ]
+            logger.info(f"Добавлено стандартное поле predefined_graphs")
+        
+        # Сохраняем обновленный файл
+        with open(PROPERTY_JSON, 'w') as f:
+            json.dump(data, f, indent=2)
+        
+        logger.info(f"{PROPERTY_JSON} успешно обновлен с добавлением поля predefined_graphs")
+        return True
     except Exception as e:
-        logger.error(f"Ошибка при создании {PROPERTY_JSON}: {e}")
+        logger.error(f"Ошибка при обновлении {PROPERTY_JSON}: {e}")
+        return False
+
+def check_and_create_property_json():
+    """Проверяет наличие property.json и создает его при необходимости"""
+    if not PROPERTY_JSON.exists():
+        logger.warning(f"{PROPERTY_JSON} не найден, создаем файл...")
+        
+        property_data = {
+            "_ten": {},  # Важное поле для TEN формата
+            "name": "TEN Agent Example",
+            "version": "0.0.1",
+            "extensions": ["openai_chatgpt"],
+            "description": "A basic voice agent with OpenAI",
+            "predefined_graphs": [  # Важное поле, которое ожидает API
+                {
+                    "name": "Voice Agent",
+                    "description": "Basic voice agent with OpenAI",
+                    "file": "voice_agent.json"
+                },
+                {
+                    "name": "Chat Agent",
+                    "description": "Simple chat agent",
+                    "file": "chat_agent.json"
+                }
+            ],
+            "graphs": [
+                {
+                    "name": "Voice Agent",
+                    "description": "Basic voice agent with OpenAI",
+                    "file": "voice_agent.json"
+                },
+                {
+                    "name": "Chat Agent",
+                    "description": "Simple chat agent",
+                    "file": "chat_agent.json"
+                }
+            ]
+        }
+        
+        # Проверяем и создаем директории
+        PROPERTY_JSON.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Создаем временный файл и затем перемещаем его
+        with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp_file:
+            json.dump(property_data, temp_file, indent=2)
+            temp_path = temp_file.name
+        
+        # Копируем временный файл в целевой
+        try:
+            shutil.copy2(temp_path, PROPERTY_JSON)
+            os.chmod(PROPERTY_JSON, 0o666)  # Устанавливаем права доступа rw-rw-rw-
+            logger.info(f"Файл {PROPERTY_JSON} создан успешно")
+        except Exception as e:
+            logger.error(f"Ошибка при создании {PROPERTY_JSON}: {e}")
+        finally:
+            os.unlink(temp_path)  # Удаляем временный файл
 
 def check_and_create_agent_files():
     """Проверяет наличие всех необходимых файлов агентов и создает их при необходимости"""
@@ -448,6 +255,41 @@ def check_files():
     subprocess.run(["stat", str(AGENTS_DIR)])
     subprocess.run(["stat", str(PROPERTY_JSON)])
 
+def analyze_api_response(response_data):
+    """Анализирует ответ API и выводит диагностическую информацию"""
+    try:
+        # Пробуем распарсить JSON
+        if not response_data or response_data.strip() == "":
+            logger.error("API вернул пустой ответ")
+            return None
+        
+        json_data = json.loads(response_data)
+        
+        # Проверяем тип данных
+        if isinstance(json_data, list):
+            logger.info(f"API вернул список с {len(json_data)} элементами")
+            if len(json_data) > 0:
+                logger.info(f"Структура первого элемента: {json.dumps(json_data[0], indent=2)}")
+            return json_data
+        elif isinstance(json_data, dict):
+            logger.info(f"API вернул словарь с ключами: {list(json_data.keys())}")
+            # Проверяем наличие кода ошибки
+            if "code" in json_data:
+                logger.error(f"API вернул ошибку с кодом: {json_data['code']}")
+                if "msg" in json_data:
+                    logger.error(f"Сообщение ошибки: {json_data['msg']}")
+            return json_data
+        else:
+            logger.warning(f"API вернул неожиданный тип данных: {type(json_data)}")
+            return json_data
+    except json.JSONDecodeError as e:
+        logger.error(f"Ошибка декодирования JSON: {e}")
+        logger.error(f"Сырые данные: {response_data}")
+        return None
+    except Exception as e:
+        logger.error(f"Ошибка при анализе ответа API: {e}")
+        return None
+
 def test_api():
     """Делает запрос к API для получения списка графов"""
     logger.info("=== Тестирование API ===")
@@ -458,47 +300,46 @@ def test_api():
             data = response.read().decode('utf-8')
             logger.info(f"Ответ /graphs: {data}")
             
-            # Проверяем структуру ответа
-            try:
-                json_data = json.loads(data)
-                if isinstance(json_data, list) and len(json_data) > 0:
+            # Анализируем ответ API
+            json_data = analyze_api_response(data)
+            
+            # Проверяем структуру ответа и реагируем на проблемы
+            if json_data is None:
+                logger.error("Не удалось проанализировать ответ API")
+            elif isinstance(json_data, list):
+                if len(json_data) > 0:
                     logger.info(f"API вернул {len(json_data)} графов")
-                    # Если API вернул пустой список, исправляем это
-                    if len(json_data) == 0:
-                        logger.warning("API вернул пустой список графов, исправляем property.json")
-                        backup_file(PROPERTY_JSON)
-                        ensure_property_json()
-                        check_and_create_agent_files()
-                        ensure_directory_permissions(AGENTS_DIR)
-                        # Перезапускаем API сервер
-                        logger.info("Перезапускаем API сервер...")
-                        subprocess.run(["pkill", "-f", str(API_BINARY)])
-                        time.sleep(1)
-                        subprocess.Popen([str(API_BINARY)])
                 else:
                     logger.warning("API вернул пустой список графов")
-            except json.JSONDecodeError:
-                logger.error("Ответ API не является валидным JSON")
+                    # Пробуем исправить property.json, если он уже существует
+                    if PROPERTY_JSON.exists():
+                        logger.info("Пробуем обновить существующий property.json...")
+                        if update_property_json():
+                            # Перезапускаем API сервер после обновления
+                            logger.info("Перезапускаем API сервер после обновления property.json...")
+                            subprocess.run(["pkill", "-f", str(API_BINARY)])
+                            time.sleep(1)
+                            subprocess.Popen([str(API_BINARY)])
+            elif isinstance(json_data, dict) and "code" in json_data:
+                logger.warning("API вернул ошибку, исправляем property.json")
+                backup_file(PROPERTY_JSON)
+                check_and_create_property_json()
+                update_property_json()  # Добавляем вызов функции обновления
+                check_and_create_agent_files()
+                ensure_directory_permissions(AGENTS_DIR)
+                # Перезапускаем API сервер
+                logger.info("Перезапускаем API сервер...")
+                subprocess.run(["pkill", "-f", str(API_BINARY)])
+                time.sleep(1)
+                subprocess.Popen([str(API_BINARY)])
     except urllib.error.URLError as e:
         logger.error(f"Ошибка запроса к API: {e}")
     except Exception as e:
         logger.error(f"Неизвестная ошибка при запросе к API: {e}")
 
-def run_mock_api_server(port=8090):
-    """Запускает мок-сервер для API дизайнера"""
-    try:
-        with socketserver.TCPServer(("", port), MockDesignerAPIHandler) as httpd:
-            logger.info(f"Запуск мок-API сервера на порту {port}")
-            httpd.serve_forever()
-    except Exception as e:
-        logger.error(f"Ошибка при запуске мок-API сервера: {e}")
-
 def main():
     processes = []
     try:
-        # Загружаем мок-ответы
-        load_mock_responses()
-        
         # Проверяем существование файлов
         if not API_BINARY.exists():
             logger.error(f"API binary не найден: {API_BINARY}")
@@ -513,7 +354,10 @@ def main():
         ensure_directory_permissions(BACKUP_DIR)
         
         # Проверяем и создаем property.json
-        ensure_property_json()
+        check_and_create_property_json()
+        
+        # Проверяем и обновляем существующий property.json, если он не содержит predefined_graphs
+        update_property_json()
         
         # Проверяем и создаем файлы агентов
         check_and_create_agent_files()
@@ -521,12 +365,6 @@ def main():
         # Проверка файлов перед запуском
         check_files()
         
-        # Запускаем мок-сервер для API дизайнера
-        mock_api_port = 8090
-        mock_api_thread = threading.Thread(target=run_mock_api_server, args=(mock_api_port,))
-        mock_api_thread.daemon = True
-        mock_api_thread.start()
-        
         # Запускаем API сервер
         logger.info("Запуск TEN-Agent API сервера на порту 8080...")
         api_process = subprocess.Popen([str(API_BINARY)])
@@ -537,23 +375,28 @@ def main():
         test_thread.daemon = True
         test_thread.start()
         
-        # Запускаем прокси-сервер для перехвата и модификации запросов
+        # Запускаем прокси-сервер
         proxy_port = 9090
-        proxy_thread = Thread(target=run_proxy_server, args=(proxy_port,))
-        proxy_thread.daemon = True
-        proxy_thread.start()
+        proxy_script = Path("proxy_server.py")
+        if proxy_script.exists():
+            logger.info(f"Запуск прокси-сервера на порту {proxy_port}")
+            proxy_process = subprocess.Popen([sys.executable, str(proxy_script)], env=dict(os.environ, PROXY_PORT=str(proxy_port)))
+            processes.append(proxy_process)
+        else:
+            logger.warning(f"Файл прокси-сервера не найден: {proxy_script}, будет использовано прямое подключение к API")
+            proxy_port = 8080  # Fallback на порт API сервера
         
         # Запускаем Playground UI в режиме dev на порту 7860 (порт Hugging Face)
         logger.info("Запуск Playground UI в режиме разработки на порту 7860...")
         os.environ["PORT"] = "7860"
-        os.environ["AGENT_SERVER_URL"] = f"http://localhost:{proxy_port}"  # Указываем прокси вместо прямого API
+        os.environ["AGENT_SERVER_URL"] = f"http://localhost:{proxy_port}"  # Используем прокси вместо прямого подключения
         os.environ["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"  # Включаем расширенный режим редактирования
         os.environ["NEXT_PUBLIC_DISABLE_CAMERA"] = "true"  # Отключаем запрос на использование камеры
         
-        # Настраиваем переменные для дизайнера
-        os.environ["NEXT_PUBLIC_DEV_MODE"] = "true"  # Включаем режим разработчика
+        # Важные переменные для отключения запросов к дизайнеру
+        os.environ["NEXT_PUBLIC_DEV_MODE"] = "false"
         os.environ["NEXT_PUBLIC_API_BASE_URL"] = "/api/agents"
-        os.environ["NEXT_PUBLIC_DESIGNER_API_URL"] = f"http://localhost:{mock_api_port}"
+        os.environ["NEXT_PUBLIC_DESIGNER_API_URL"] = f"http://localhost:{proxy_port}"  # Используем прокси для запросов дизайнера
         
         # Запускаем Playground UI
         playground_process = subprocess.Popen(

proxy_server.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+import http.server
+import socketserver
+import urllib.request
+import urllib.error
+import json
+import logging
+import sys
+import os
+from pathlib import Path
+
+# Настройка логирования
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s [%(levelname)s] %(message)s',
+                    datefmt='%Y-%m-%d %H:%M:%S')
+
+logger = logging.getLogger('ten-proxy')
+
+# Настройки прокси
+PROXY_PORT = 9090
+API_SERVER = "http://localhost:8080"
+
+# Мок-данные для /graphs
+MOCK_GRAPHS_RESPONSE = [
+    {
+        "name": "Voice Agent",
+        "description": "Voice Agent with OpenAI",
+        "file": "voice_agent.json",
+        "id": "voice_agent",
+        "package": "default"
+    },
+    {
+        "name": "Chat Agent",
+        "description": "Chat Agent",
+        "file": "chat_agent.json",
+        "id": "chat_agent",
+        "package": "default"
+    }
+]
+
+# Мок-данные для designer API
+MOCK_DESIGNER_RESPONSE = {
+    "success": True,
+    "packages": [
+        {
+            "name": "default",
+            "description": "Default package",
+            "graphs": [
+                {
+                    "name": "Voice Agent",
+                    "description": "Voice Agent with OpenAI",
+                    "file": "voice_agent.json",
+                    "id": "voice_agent",
+                    "package": "default"
+                },
+                {
+                    "name": "Chat Agent",
+                    "description": "Chat Agent",
+                    "file": "chat_agent.json",
+                    "id": "chat_agent",
+                    "package": "default"
+                }
+            ]
+        }
+    ]
+}
+
+class ProxyHandler(http.server.BaseHTTPRequestHandler):
+    """Обработчик запросов для прокси-сервера"""
+    
+    def do_GET(self):
+        """Обработка GET запросов"""
+        logger.info(f"PROXY: GET запрос: {self.path}")
+        
+        # Перехватываем запросы к /graphs
+        if self.path == "/graphs":
+            self._handle_graphs_request()
+        # Перехватываем запросы к designer API
+        elif self.path.startswith("/api/designer/") or self.path.startswith("/api/dev/"):
+            self._handle_designer_request()
+        # Все остальные запросы перенаправляем на API сервер
+        else:
+            self._proxy_request("GET")
+    
+    def do_POST(self):
+        """Обработка POST запросов"""
+        logger.info(f"PROXY: POST запрос: {self.path}")
+        
+        # Перехватываем запросы к designer API
+        if self.path.startswith("/api/designer/") or self.path.startswith("/api/dev/"):
+            self._handle_designer_request()
+        # Все остальные запросы перенаправляем на API сервер
+        else:
+            self._proxy_request("POST")
+    
+    def do_OPTIONS(self):
+        """Обработка OPTIONS запросов для CORS"""
+        self.send_response(200)
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+        self.end_headers()
+    
+    def _handle_graphs_request(self):
+        """Обрабатывает запросы к /graphs с возможностью модификации ответа"""
+        try:
+            # Сначала пробуем получить данные от реального API
+            url = f"{API_SERVER}{self.path}"
+            try:
+                with urllib.request.urlopen(url) as response:
+                    data = response.read().decode('utf-8')
+                    
+                    # Проверяем, является ли ответ валидным JSON
+                    try:
+                        json_data = json.loads(data)
+                        
+                        # Если API вернул пустой список или ошибку, заменяем на мок-данные
+                        if (isinstance(json_data, list) and len(json_data) == 0) or (isinstance(json_data, dict) and "code" in json_data):
+                            logger.warning(f"API вернул пустой список или ошибку, используем мок-данные")
+                            self._send_success_response(MOCK_GRAPHS_RESPONSE)
+                            return
+                        
+                        # Если всё нормально, возвращаем оригинальный ответ
+                        logger.info(f"API вернул непустой список графов, используем его")
+                        self._send_response_with_data(200, data)
+                        return
+                    except json.JSONDecodeError:
+                        logger.error(f"Ответ API не является валидным JSON: {data}")
+                        self._send_success_response(MOCK_GRAPHS_RESPONSE)
+                        return
+            except urllib.error.URLError as e:
+                logger.error(f"Не удалось подключиться к API: {e}")
+                # В случае ошибки используем мок-данные
+                self._send_success_response(MOCK_GRAPHS_RESPONSE)
+                return
+        except Exception as e:
+            logger.error(f"Ошибка при обработке запроса /graphs: {e}")
+            self._send_success_response(MOCK_GRAPHS_RESPONSE)
+    
+    def _handle_designer_request(self):
+        """Обрабатывает запросы к designer API, всегда возвращая мок-данные"""
+        logger.info(f"Перехват запроса к Designer API: {self.path}")
+        self._send_success_response(MOCK_DESIGNER_RESPONSE)
+    
+    def _proxy_request(self, method):
+        """Перенаправляет запрос на API сервер"""
+        try:
+            url = f"{API_SERVER}{self.path}"
+            
+            # Получение данных запроса для POST
+            data = None
+            if method == "POST":
+                content_length = int(self.headers.get('Content-Length', 0))
+                data = self.rfile.read(content_length)
+            
+            # Создание запроса
+            req = urllib.request.Request(url, data=data, method=method)
+            
+            # Копирование заголовков
+            for header, value in self.headers.items():
+                if header.lower() not in ["host", "content-length"]:
+                    req.add_header(header, value)
+            
+            # Выполнение запроса
+            try:
+                with urllib.request.urlopen(req) as response:
+                    # Чтение данных ответа
+                    response_data = response.read()
+                    
+                    # Отправка ответа клиенту
+                    self.send_response(response.status)
+                    
+                    # Копирование заголовков ответа
+                    for header, value in response.getheaders():
+                        if header.lower() != "transfer-encoding":
+                            self.send_header(header, value)
+                    
+                    # Добавление CORS заголовков
+                    self.send_header('Access-Control-Allow-Origin', '*')
+                    self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+                    self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+                    
+                    self.end_headers()
+                    self.wfile.write(response_data)
+            except urllib.error.URLError as e:
+                logger.error(f"Ошибка при проксировании запроса: {e}")
+                self.send_error(502, f"Bad Gateway: {e}")
+        except Exception as e:
+            logger.error(f"Ошибка при обработке запроса: {e}")
+            self.send_error(500, f"Internal Server Error: {e}")
+    
+    def _send_success_response(self, data):
+        """Отправляет успешный ответ с данными"""
+        response_data = json.dumps(data)
+        self._send_response_with_data(200, response_data)
+    
+    def _send_response_with_data(self, status_code, data):
+        """Отправляет ответ с указанным статусом и данными"""
+        self.send_response(status_code)
+        self.send_header('Content-Type', 'application/json')
+        self.send_header('Access-Control-Allow-Origin', '*')
+        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
+        self.end_headers()
+        
+        if isinstance(data, str):
+            self.wfile.write(data.encode('utf-8'))
+        else:
+            self.wfile.write(data)
+    
+    def log_message(self, format, *args):
+        """Настраиваем логирование для сервера"""
+        logger.debug(f"PROXY: {self.address_string()} - {format % args}")
+
+def run_proxy_server(port=PROXY_PORT):
+    """Запускает прокси-сервер"""
+    try:
+        with socketserver.TCPServer(("", port), ProxyHandler) as httpd:
+            logger.info(f"Запуск прокси-сервера на порту {port}")
+            httpd.serve_forever()
+    except KeyboardInterrupt:
+        logger.info("Прокси-сервер остановлен")
+    except Exception as e:
+        logger.error(f"Ошибка при запуске ��рокси-сервера: {e}")
+
+if __name__ == "__main__":
+    # Запуск прокси-сервера
+    proxy_port = int(os.environ.get("PROXY_PORT", PROXY_PORT))
+    run_proxy_server(proxy_port)