Fix TEN-Agent for HuggingFace Space: Replace Go server with Python wrapper

.env.example

@@ -1,7 +1,6 @@
 # Server Configuration
 LOG_PATH=/tmp/ten_agent
 LOG_STDOUT=true
-SERVER_PORT=7860
 
 # Agora App ID and App Certificate
 AGORA_APP_ID=
@@ -16,4 +15,9 @@ OPENAI_MODEL=gpt-4o
 DEEPGRAM_API_KEY=
 
 # Text to Speech
-ELEVENLABS_TTS_KEY=
+ELEVENLABS_API_KEY=
+
+# Ports configuration
+API_PORT=8080
+UI_PORT=3000
+GRADIO_PORT=7860

.space/README.md

@@ -0,0 +1,16 @@
+# TEN-Agent на Hugging Face Space
+
+Этот файл содержит конфигурацию для запуска TEN-Agent на Hugging Face Space.
+
+## Особенности
+
+- Использует Python API Wrapper вместо оригинального Go-сервера
+- Хранит все временные файлы в директории `/tmp/ten_user`
+- Запускает UI через Gradio
+
+## Запуск
+
+Для запуска используется скрипт `hf-space.sh`, который:
+1. Создает необходимые директории
+2. Проверяет наличие файлов
+3. Запускает приложение через `app.py` 

.space/hf-space.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+echo "===== Starting TEN-Agent in Python Wrapper Mode ====="
+echo "$(date)"
+echo "Current directory: $(pwd)"
+
+echo "===== Environment Information ====="
+echo "User: $(whoami || echo 'Unknown')"
+echo "Groups: $(groups || echo 'Unknown')"
+echo "Home directory: $HOME"
+
+# Создаем необходимые директории
+echo "Creating temporary directories in /tmp..."
+mkdir -p /tmp/ten_user/agents
+mkdir -p /tmp/ten_user/logs
+chmod -R 777 /tmp/ten_user
+
+# Проверяем наличие файлов
+echo "Checking necessary files..."
+if [ -f "api_wrapper.py" ]; then
+    echo "✅ api_wrapper.py found"
+else
+    echo "❌ api_wrapper.py missing!"
+    exit 1
+fi
+
+if [ -f "app.py" ]; then
+    echo "✅ app.py found"
+else
+    echo "❌ app.py missing!"
+    exit 1
+fi
+
+# Проверяем python и зависимости
+echo "Checking Python..."
+python3 --version
+python3 -c "import gradio; import fastapi; print('✅ All dependencies installed')" || echo "❌ Dependencies missing"
+
+# Запускаем приложение через Python wrapper
+echo "Starting TEN-Agent via Python wrapper (app.py)..."
+python3 app.py 

Dockerfile

@@ -1,82 +1,54 @@
-FROM ubuntu:22.04
+FROM node:18
 
-# Установка базовых пакетов
+WORKDIR /app
+
+# Устанавливаем Python
 RUN apt-get update && apt-get install -y \
-    curl \
-    git \
-    wget \
-    make \
-    gcc \
-    build-essential \
-    libasound2 \
-    libgstreamer1.0-dev \
-    libunwind-dev \
-    libc++1 \
-    libssl-dev \
     python3 \
-    python3-venv \
     python3-pip \
-    python3-dev \
-    unzip \
-    jq \
-    vim \
-    ca-certificates \
-    && apt-get clean && rm -rf /var/lib/apt/lists/* && rm -rf /tmp/*
-
-# Установка Go
-RUN wget https://golang.org/dl/go1.21.0.linux-amd64.tar.gz && \
-    tar -C /usr/local -xzf go1.21.0.linux-amd64.tar.gz && \
-    rm go1.21.0.linux-amd64.tar.gz
+    git \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
 
-# Настройка окружения Go
-ENV PATH=$PATH:/usr/local/go/bin
-ENV GOPATH=/go
-ENV PATH=$PATH:$GOPATH/bin
-RUN mkdir -p /go && chmod 777 /go
+# Копируем файлы API wrapper и конфигурации
+COPY api_wrapper.py /app/
+COPY app.py /app/
+COPY proxy.py /app/
+COPY .space/hf-space.sh /app/
 
-# Создание директории для кэша Go
-ENV GOCACHE=/tmp/go-cache
-RUN mkdir -p /tmp/go-cache && chmod 777 /tmp/go-cache
+# Создаем директории
+RUN mkdir -p /tmp/ten_user/agents /tmp/ten_user/logs /app/backup
+RUN chmod -R 777 /tmp /app/backup
 
-# Установка Node.js и pnpm
-RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
-    apt-get install -y nodejs && \
-    npm install -g pnpm
+# Устанавливаем Python зависимости
+COPY requirements.txt /app/
+RUN pip3 install -r requirements.txt
 
-# Клонирование репозитория TEN-Agent
-WORKDIR /app
-RUN git clone --depth 1 https://github.com/TEN-framework/TEN-Agent.git /app
+# Клонируем репозиторий TEN-Agent
+RUN git clone --depth 1 https://github.com/TEN-framework/TEN-Agent.git /tmp/ten-agent
 
-# Создание пользовательских директорий для временных файлов
-RUN mkdir -p /tmp/ten_user && chmod 777 /tmp/ten_user
-RUN mkdir -p /app/fallback && chmod 777 /app/fallback
+# Копируем только необходимые файлы из репозитория
+RUN mkdir -p /app/playground
+RUN cp -r /tmp/ten-agent/playground/* /app/playground/
+RUN rm -rf /tmp/ten-agent
 
-# Компиляция API сервера
-RUN mkdir -p /app/server/bin && \
-    cd /app/server && \
-    GOCACHE=/tmp/go-cache go build -o bin/api main.go && \
-    chmod +x bin/api && \
-    cp bin/api /app/fallback/api && \
-    chmod 777 /app/fallback/api
+# Устанавливаем pnpm
+RUN npm install -g pnpm@8
 
-# Проверяем, что API сервер скомпилирован
-RUN ls -la /app/server/bin/api /app/fallback/api
+# Устанавливаем dependencies для playground
+WORKDIR /app/playground
+RUN pnpm install
 
-# Создание .env файла из окружения Hugging Face Space
-# Используем простой формат без пробелов для предотвращения ошибок
-RUN echo "AGORA_APP_ID=${AGORA_APP_ID}\nAGORA_APP_CERTIFICATE=${AGORA_APP_CERTIFICATE}\nAZURE_STT_KEY=${AZURE_STT_KEY}\nAZURE_STT_REGION=${AZURE_STT_REGION}\nAZURE_TTS_KEY=${AZURE_TTS_KEY}\nAZURE_TTS_REGION=${AZURE_TTS_REGION}\nOPENAI_API_KEY=${OPENAI_API_KEY}" > /app/.env
-
-# Предварительная установка зависимостей для playground
-# Делаем это отдельно, чтобы не пересобирать при каждом изменении
-RUN cd /app/playground && pnpm install
+# Возвращаемся в основную директорию
+WORKDIR /app
 
-# Копируем стартовые скрипты
-COPY start.sh /app/start.sh
-COPY fallback.py /app/fallback.py
-RUN chmod +x /app/start.sh /app/fallback.py
+# Делаем скрипт запуска исполняемым
+RUN chmod +x /app/hf-space.sh
 
-# Открываем порты (7860 для HF Space, 8080 для API)
-EXPOSE 7860 8080
+# Экспортируем порт
+EXPOSE 7860 3000 8080
 
-# Запускаем TEN-Agent через fallback скрипт
+# Запускаем приложение через скрипт
+COPY start.sh /app/
+RUN chmod +x /app/start.sh
 CMD ["/app/start.sh"]

README.md

@@ -5,6 +5,8 @@ colorFrom: blue
 colorTo: purple
 sdk: docker
 sdk_version: "latest"
+app_port: 7860
+app_file: app.py
 pinned: false
 ---
 
@@ -21,17 +23,63 @@ pinned: false
 
 # TEN-Agent на Hugging Face Space
 
-Это официальная версия [TEN-Agent](https://github.com/TEN-framework/TEN-Agent), развернутая на Hugging Face Space. Приложение позволяет взаимодействовать с голосовыми и чат-агентами, используя различные языковые модели и расширения.
+Это адаптированная версия [TEN-Agent](https://github.com/TEN-framework/TEN-Agent) для работы на платформе Hugging Face Spaces.
 
-## Что такое TEN-Agent?
+## Описание
 
-TEN Agent - это конверсационный голосовой ИИ-агент, работающий на платформе TEN, интегрирующий Deepseek, Gemini, OpenAI, технологии RTC, и даже аппаратные возможности ESP32. Он обеспечивает возможности ИИ в реальном времени, такие как зрение, слух и речь, и полностью совместим с платформами Dify и Coze.
+TEN-Agent - это разговорный голосовой AI-агент, работающий на базе фреймворка TEN. Он интегрирует различные LLM модели, включая Deepseek, Gemini, OpenAI, технологии RTC и другие инструменты.
 
-## Как использовать?
+## Особенности
 
-1. Выберите тип графа (например, Voice Agent, Chat Agent)
-2. Выберите соответствующий модуль
-3. Выберите расширение и настройте параметры API-ключей
+- 🗣️ **Голосовое общение**: Интеграция с ASR (распознавание речи) и TTS (синтез речи)
+- 👀 **Зрение**: Обработка и анализ изображений с камеры
+- 🧠 **Различные LLM**: Поддержка OpenAI, Gemini, DeepSeek и других
+- 🔗 **Расширения**: Модульная архитектура с возможностью добавления новых функций
+
+## Метод запуска (ВАЖНО!)
+
+Для решения проблем с запуском в Hugging Face Space, мы используем:
+
+1. **Python API Wrapper** вместо оригинального Go-сервера
+2. **Хранение всех файлов** в директории `/tmp/ten_user`
+3. **Запуск через app.py**, а не через оригинальные скрипты
+
+> **Эта версия специально адаптирована для Hugging Face Space и решает проблемы с правами доступа!**
+
+## Настройка
+
+В интерфейсе необходимо настроить следующие API ключи:
+
+1. **OpenAI API Key**: Для текстовой обработки
+2. **Deepgram API Key**: Для распознавания речи 
+3. **ElevenLabs API Key**: Для генерации голоса
+4. **Agora App ID и App Certificate**: Для работы с RTC
+
+## Графы
+
+В системе предустановлены два графа:
+
+1. **Voice Agent**: Голосовой агент с OpenAI и ElevenLabs
+2. **Chat Agent**: Текстовый чат с OpenAI
+
+## Как использовать
+
+1. Дождитесь полной загрузки интерфейса
+2. Нажмите на кнопку "Открыть TEN Agent UI"
+3. В новой вкладке настройте API ключи
+4. Выберите нужный график и начните общение с агентом
+
+## Ограничения
+
+В текущей версии на Hugging Face Space имеются следующие ограничения:
+
+- Ограниченная производительность веб-интерфейса
+- Отсутствие постоянного хранилища для загружаемых файлов
+- Некоторые функции могут работать медленнее, чем в локальной установке
+
+## Запуск локально
+
+Для локального запуска полной версии следуйте инструкциям в [официальном репозитории](https://github.com/TEN-framework/TEN-Agent).
 
 ## Доступные функции
 
@@ -42,9 +90,11 @@ TEN Agent - это конверсационный голосовой ИИ-аге
 
 ## Технические детали
 
-Этот Space полностью воспроизводит официальный контейнер TEN-Agent, используя систему сборки `task` с командами:
-- `task use` - для сборки агента
-- `task run` - для запуска сервера
+Этот Space использует свой собственный метод запуска через Python-обертку:
+
+```python
+python3 app.py
+```
 
 ## Ссылки
 

api_wrapper.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+import http.server
+import json
+import os
+import sys
+import logging
+from pathlib import Path
+import time
+from urllib.parse import parse_qs, urlparse
+
+# Настройка логирования
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger("ten_api")
+
+# Проверяем, запущены ли мы в HuggingFace Space
+IS_HF_SPACE = os.environ.get("SPACE_ID") is not None
+USE_WRAPPER = os.environ.get("USE_WRAPPER", "false").lower() in ("true", "1", "yes")
+
+# Путь к директории с агентами
+if IS_HF_SPACE or USE_WRAPPER:
+    TMP_DIR = os.environ.get("TMP_DIR", "/tmp/ten_user")
+    AGENT_DIR = os.environ.get("TEN_AGENT_DIR", f"{TMP_DIR}/agents")
+else:
+    AGENT_DIR = os.environ.get("TEN_AGENT_DIR", "/tmp/ten_user/agents")
+
+logger.info(f"Using agent directory: {AGENT_DIR}")
+logger.info(f"Running in HuggingFace Space: {IS_HF_SPACE}")
+logger.info(f"Using Wrapper: {USE_WRAPPER}")
+
+class TENAgentHandler(http.server.BaseHTTPRequestHandler):
+    def log_message(self, format, *args):
+        """Переопределение логирования для вывода в stdout"""
+        logger.info("%s - %s", self.address_string(), format % args)
+        
+    def _set_headers(self, content_type="application/json"):
+        self.send_response(200)
+        self.send_header('Content-type', content_type)
+        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, Authorization')
+        self.end_headers()
+        
+    def do_OPTIONS(self):
+        self._set_headers()
+        
+    def do_GET(self):
+        logger.info(f"GET request: {self.path}")
+        
+        # Разбор URL для параметров
+        parsed_url = urlparse(self.path)
+        path = parsed_url.path
+        query_params = parse_qs(parsed_url.query)
+        
+        # Обрабатываем API endpoints
+        if path == "/graphs" or path == "/api/graphs":
+            self._handle_graphs()
+        elif path == "/health" or path == "/":
+            self._handle_health()
+        elif path == "/list":
+            self._handle_list()
+        elif path == "/dev-tmp/addons/default-properties":
+            self._handle_default_properties()
+        elif path == "/vector/document/preset/list":
+            self._handle_vector_preset_list()
+        elif path.startswith("/api/dev/v1/packages"):
+            self._handle_packages()
+        elif path.startswith("/api/designer/v1/packages"):
+            self._handle_packages()
+        else:
+            # Для всех остальных запросов возвращаем 404
+            self.send_error(404, f"Not found: {path}")
+    
+    def _handle_graphs(self):
+        """Обработка запроса на получение списка графов"""
+        try:
+            property_file = Path(AGENT_DIR) / "property.json"
+            if not property_file.exists():
+                logger.error(f"Property file not found at {property_file}")
+                self.send_error(404, "Property file not found")
+                return
+            
+            with open(property_file, "r") as f:
+                property_data = json.load(f)
+            
+            graphs = property_data.get("graphs", [])
+            self._set_headers()
+            self.wfile.write(json.dumps(graphs).encode())
+            logger.info(f"Returned {len(graphs)} graphs")
+        except Exception as e:
+            logger.error(f"Error reading property.json: {e}")
+            self.send_error(500, f"Internal error: {e}")
+    
+    def _handle_health(self):
+        """Обработка запроса на проверку статуса сервера"""
+        self._set_headers()
+        self.wfile.write(json.dumps({
+            "status": "ok", 
+            "time": time.time(), 
+            "is_hf_space": IS_HF_SPACE,
+            "using_wrapper": True
+        }).encode())
+    
+    def _handle_list(self):
+        """Обработка запроса на получение списка активных сессий"""
+        self._set_headers()
+        self.wfile.write(json.dumps([]).encode())
+    
+    def _handle_default_properties(self):
+        """Обработка запроса на получение настроек по умолчанию"""
+        self._set_headers()
+        self.wfile.write(json.dumps({}).encode())
+    
+    def _handle_vector_preset_list(self):
+        """Обработка запроса на получение списка пресетов векторов"""
+        self._set_headers()
+        self.wfile.write(json.dumps([]).encode())
+    
+    def _handle_packages(self):
+        """Обработка запросов к пакетам"""
+        # Этот м��тод эмулирует возврат списка графов и для других эндпоинтов
+        try:
+            property_file = Path(AGENT_DIR) / "property.json"
+            if not property_file.exists():
+                logger.error(f"Property file not found at {property_file}")
+                self.send_error(404, "Property file not found")
+                return
+            
+            with open(property_file, "r") as f:
+                property_data = json.load(f)
+            
+            graphs = property_data.get("graphs", [])
+            self._set_headers()
+            response_data = {
+                "data": graphs,
+                "status": 200,
+                "message": "Success"
+            }
+            self.wfile.write(json.dumps(response_data).encode())
+            logger.info(f"Handled packages request and returned {len(graphs)} graphs")
+        except Exception as e:
+            logger.error(f"Error handling packages request: {e}")
+            self.send_error(500, f"Internal error: {e}")
+    
+    def do_POST(self):
+        logger.info(f"POST request: {self.path}")
+        
+        # Читаем тело запроса
+        content_length = int(self.headers['Content-Length']) if 'Content-Length' in self.headers else 0
+        post_data = self.rfile.read(content_length)
+        
+        try:
+            request_data = json.loads(post_data) if content_length > 0 else {}
+        except json.JSONDecodeError:
+            request_data = {}
+            
+        logger.info(f"Request data: {json.dumps(request_data)[:200]}...")
+        
+        # Обрабатываем различные POST запросы
+        if self.path == "/ping":
+            self._handle_ping()
+        elif self.path == "/token/generate":
+            self._handle_token_generate(request_data)
+        elif self.path == "/start":
+            self._handle_start(request_data)
+        elif self.path == "/stop":
+            self._handle_stop(request_data)
+        elif self.path == "/vector/document/update" or self.path == "/vector/document/upload":
+            self._handle_vector_document(request_data)
+        elif self.path.startswith("/api/dev/v1/packages") or self.path.startswith("/api/designer/v1/packages"):
+            self._handle_packages_post(request_data)
+        else:
+            # Для всех остальных запросов возвращаем 404
+            self.send_error(404, f"Not found: {self.path}")
+    
+    def _handle_ping(self):
+        """Обработка ping запроса"""
+        self._set_headers()
+        self.wfile.write(json.dumps({
+            "status": "ok", 
+            "timestamp": time.time(),
+            "server": "ten-agent-api-wrapper",
+            "in_hf_space": IS_HF_SPACE
+        }).encode())
+    
+    def _handle_token_generate(self, request_data):
+        """Обработка запроса на генерацию токена"""
+        self._set_headers()
+        response = {
+            "token": "dummy_token_for_agora",
+            "request_id": request_data.get("RequestId", ""),
+            "channel_name": request_data.get("ChannelName", ""),
+            "uid": request_data.get("Uid", 0)
+        }
+        self.wfile.write(json.dumps(response).encode())
+        logger.info(f"Generated token for channel: {request_data.get('ChannelName', '')}")
+    
+    def _handle_start(self, request_data):
+        """Обработка запроса на запуск сессии"""
+        self._set_headers()
+        # Возвращаем успешный статус и ID сессии
+        response = {
+            "status": "ok",
+            "session_id": f"dummy_session_{int(time.time())}",
+            "message": "Session started successfully",
+            "graph_file": request_data.get("graph_file", "unknown")
+        }
+        self.wfile.write(json.dumps(response).encode())
+        logger.info(f"Started session with graph: {request_data.get('graph_file', '')}")
+    
+    def _handle_stop(self, request_data):
+        """Обработка запроса на остановку сессии"""
+        self._set_headers()
+        self.wfile.write(json.dumps({
+            "status": "ok",
+            "message": "Session stopped successfully"
+        }).encode())
+        logger.info(f"Stopped session: {request_data.get('session_id', '')}")
+    
+    def _handle_vector_document(self, request_data):
+        """Обработка запроса на работу с векторными документами"""
+        self._set_headers()
+        self.wfile.write(json.dumps({
+            "status": "ok",
+            "document_id": f"dummy_doc_{int(time.time())}",
+            "message": "Document processed successfully"
+        }).encode())
+        logger.info(f"Processed vector document: {request_data.get('name', 'unnamed')}")
+    
+    def _handle_packages_post(self, request_data):
+        """Обработка POST запросов к пакетам"""
+        self._set_headers()
+        response_data = {
+            "data": {},
+            "status": 200,
+            "message": "Success"
+        }
+        self.wfile.write(json.dumps(response_data).encode())
+        logger.info(f"Handled packages POST request")
+
+def run(server_class=http.server.HTTPServer, handler_class=TENAgentHandler, port=8080):
+    server_address = ('', port)
+    httpd = server_class(server_address, handler_class)
+    logger.info(f"Starting API server on port {port}...")
+    logger.info(f"Using agent directory: {AGENT_DIR}")
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+    except Exception as e:
+        logger.error(f"Server error: {e}")
+        raise
+
+if __name__ == "__main__":
+    port = int(os.environ.get("API_PORT", 8080))
+    try:
+        run(port=port)
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+    except Exception as e:
+        logger.error(f"Server error: {e}") 

app.py

@@ -12,219 +12,395 @@ import http.server
 import socketserver
 import urllib.request
 import urllib.error
+import gradio as gr
 
-def check_and_create_property_json():
-    """Проверяет наличие property.json и создает его при необходимости"""
-    property_path = Path("/app/agents/property.json")
+# Проверяем, запущены ли мы в HuggingFace Space
+IS_HF_SPACE = os.environ.get("SPACE_ID") is not None
+print(f"Running in HuggingFace Space: {IS_HF_SPACE}")
+
+# Конфигурация путей
+TMP_DIR = Path("/tmp/ten_user")
+AGENTS_DIR = TMP_DIR / "agents"
+LOGS_DIR = TMP_DIR / "logs"
+NEXTJS_PORT = int(os.environ.get("UI_PORT", 3000))
+API_PORT = int(os.environ.get("API_PORT", 8080))
+GRADIO_PORT = int(os.environ.get("GRADIO_PORT", 7860))
+
+# Адрес для подключения к UI в iframe
+if IS_HF_SPACE:
+    # В HuggingFace Space нужно использовать внутренний URL
+    UI_URL = f"https://{os.environ.get('SPACE_ID', 'unknown-space')}.hf.space/_next/iframe/3000"
+    INTERNAL_HOST = "0.0.0.0"
+else:
+    # В локальном окружении используем localhost
+    UI_URL = f"http://localhost:{NEXTJS_PORT}"
+    INTERNAL_HOST = "localhost"
+
+def create_directories():
+    """Создает необходимые директории"""
+    print("Создание директорий...")
     
-    if not property_path.exists():
-        print(f"WARNING: {property_path} не найден, создаем файл...")
-        
-        property_data = {
-            "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"
+    TMP_DIR.mkdir(exist_ok=True, parents=True)
+    AGENTS_DIR.mkdir(exist_ok=True, parents=True)
+    LOGS_DIR.mkdir(exist_ok=True, parents=True)
+    
+    # Создаем пустой файл логов
+    (LOGS_DIR / "server.log").touch()
+    print(f"Директории созданы в {TMP_DIR}")
+
+def create_config_files():
+    """Создает базовые файлы конфигурации"""
+    print("Создание конфигурационных файлов...")
+    
+    # Создаем property.json с графами
+    property_data = {
+        "name": "TEN Agent Demo",
+        "version": "0.0.1",
+        "extensions": ["openai_chatgpt", "elevenlabs_tts", "deepgram_asr"],
+        "description": "TEN Agent on Hugging Face Space",
+        "graphs": [
+            {
+                "name": "Voice Agent",
+                "description": "Basic voice agent with OpenAI and ElevenLabs",
+                "file": "voice_agent.json"
+            },
+            {
+                "name": "Chat Agent",
+                "description": "Simple chat agent with OpenAI",
+                "file": "chat_agent.json"
+            }
+        ]
+    }
+    
+    with open(AGENTS_DIR / "property.json", "w") as f:
+        json.dump(property_data, f, indent=2)
+    
+    # Создаем voice_agent.json
+    voice_agent = {
+        "_ten": {"version": "0.0.1"},
+        "nodes": [
+            {
+                "id": "start",
+                "type": "start",
+                "data": {"x": 100, "y": 100}
+            },
+            {
+                "id": "openai_chatgpt",
+                "type": "openai_chatgpt",
+                "data": {
+                    "x": 300,
+                    "y": 200,
+                    "properties": {
+                        "model": "gpt-3.5-turbo",
+                        "temperature": 0.7,
+                        "system_prompt": "You are a helpful assistant."
+                    }
                 }
-            ]
-        }
+            },
+            {
+                "id": "elevenlabs_tts",
+                "type": "elevenlabs_tts",
+                "data": {
+                    "x": 500,
+                    "y": 200,
+                    "properties": {
+                        "voice_id": "21m00Tcm4TlvDq8ikWAM"
+                    }
+                }
+            },
+            {
+                "id": "deepgram_asr",
+                "type": "deepgram_asr",
+                "data": {
+                    "x": 300,
+                    "y": 300,
+                    "properties": {
+                        "language": "ru"
+                    }
+                }
+            },
+            {
+                "id": "end",
+                "type": "end",
+                "data": {"x": 700, "y": 100}
+            }
+        ],
+        "edges": [
+            {"id": "start_to_chatgpt", "source": "start", "target": "openai_chatgpt"},
+            {"id": "chatgpt_to_tts", "source": "openai_chatgpt", "target": "elevenlabs_tts"},
+            {"id": "tts_to_end", "source": "elevenlabs_tts", "target": "end"},
+            {"id": "asr_to_chatgpt", "source": "deepgram_asr", "target": "openai_chatgpt"}
+        ],
+        "groups": [],
+        "templates": [],
+        "root": "start"
+    }
+    
+    with open(AGENTS_DIR / "voice_agent.json", "w") as f:
+        json.dump(voice_agent, f, indent=2)
+    
+    # Создаем chat_agent.json (упрощенная версия)
+    chat_agent = {
+        "_ten": {"version": "0.0.1"},
+        "nodes": [
+            {
+                "id": "start",
+                "type": "start",
+                "data": {"x": 100, "y": 100}
+            },
+            {
+                "id": "openai_chatgpt",
+                "type": "openai_chatgpt",
+                "data": {
+                    "x": 300,
+                    "y": 200,
+                    "properties": {
+                        "model": "gpt-3.5-turbo",
+                        "temperature": 0.7,
+                        "system_prompt": "You are a helpful chat assistant."
+                    }
+                }
+            },
+            {
+                "id": "end",
+                "type": "end",
+                "data": {"x": 500, "y": 100}
+            }
+        ],
+        "edges": [
+            {"id": "start_to_chatgpt", "source": "start", "target": "openai_chatgpt"},
+            {"id": "chatgpt_to_end", "source": "openai_chatgpt", "target": "end"}
+        ],
+        "groups": [],
+        "templates": [],
+        "root": "start"
+    }
+    
+    with open(AGENTS_DIR / "chat_agent.json", "w") as f:
+        json.dump(chat_agent, f, indent=2)
+    
+    print("Конфигурационные файлы созданы успешно")
+
+def start_api_server():
+    """Запускает API сервер"""
+    print("Запуск API сервера...")
+    
+    # Устанавливаем переменные окружения
+    api_env = os.environ.copy()
+    api_env["TEN_AGENT_DIR"] = str(AGENTS_DIR)
+    api_env["API_PORT"] = str(API_PORT)
+    
+    # В HuggingFace Space нужны дополнительные настройки
+    if IS_HF_SPACE:
+        print("Configuring API server for HuggingFace Space environment...")
+        # Указываем серверу специально использовать API wrapper
+        api_env["USE_WRAPPER"] = "true"
+        # Отключаем логирование в файл
+        api_env["TEN_LOG_DISABLE_FILE"] = "true"
+        # Указываем путь для временных файлов
+        api_env["TMP_DIR"] = str(TMP_DIR)
+    
+    # Запускаем Python API wrapper
+    api_cmd = ["python", "api_wrapper.py"]
+    print(f"Running API command: {' '.join(api_cmd)}")
+    api_process = subprocess.Popen(
+        api_cmd,
+        env=api_env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE
+    )
+    
+    # Ждем запуска сервера
+    time.sleep(2)
+    
+    # Проверяем, что процесс не упал
+    if api_process.poll() is not None:
+        stdout, stderr = api_process.communicate()
+        print(f"API сервер не запустился!")
+        print(f"STDOUT: {stdout.decode()}")
+        print(f"STDERR: {stderr.decode()}")
+        return None
+    
+    print(f"API server started and listening on port {API_PORT}")
+    
+    # Запускаем поток для вывода логов
+    def log_output(process, prefix):
+        for line in iter(process.stdout.readline, b''):
+            print(f"[{prefix}] {line.decode().strip()}")
+        for line in iter(process.stderr.readline, b''):
+            print(f"[{prefix} ERROR] {line.decode().strip()}")
+    
+    log_thread = threading.Thread(target=log_output, args=(api_process, "API"))
+    log_thread.daemon = True
+    log_thread.start()
+    
+    return api_process
+
+def start_playground():
+    """Запускает Playground UI через Next.js"""
+    print("Запуск Playground UI...")
+    
+    # Устанавливаем переменные окружения
+    ui_env = os.environ.copy()
+    ui_env["PORT"] = str(NEXTJS_PORT)
+    ui_env["AGENT_SERVER_URL"] = f"http://{INTERNAL_HOST}:{API_PORT}"
+    ui_env["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"
+    ui_env["NEXT_PUBLIC_DISABLE_CAMERA"] = "false"
+    
+    # В HuggingFace Space нужны дополнительные настройки
+    if IS_HF_SPACE:
+        print("Configuring for HuggingFace Space environment...")
+        ui_env["NEXT_PUBLIC_IS_HF_SPACE"] = "true"
+        # Отключаем строгие проверки CORS для работы в iframe
+        ui_env["NEXT_PUBLIC_DISABLE_CORS"] = "true"
+    
+    # Запускаем UI
+    ui_cmd = "cd playground && npm run dev"
+    print(f"Running UI command: {ui_cmd}")
+    ui_process = subprocess.Popen(
+        ui_cmd,
+        env=ui_env,
+        shell=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE
+    )
+    
+    # Ждем запуска UI
+    time.sleep(5)
+    
+    # Проверяем, что процесс не упал
+    if ui_process.poll() is not None:
+        stdout, stderr = ui_process.communicate()
+        print(f"Playground UI не запустился!")
+        print(f"STDOUT: {stdout.decode()}")
+        print(f"STDERR: {stderr.decode()}")
+        return None
+    
+    # Запускаем поток для вывода логов
+    def log_output(process, prefix):
+        for line in iter(process.stdout.readline, b''):
+            print(f"[{prefix}] {line.decode().strip()}")
+        for line in iter(process.stderr.readline, b''):
+            print(f"[{prefix} ERROR] {line.decode().strip()}")
+    
+    log_thread = threading.Thread(target=log_output, args=(ui_process, "UI"))
+    log_thread.daemon = True
+    log_thread.start()
+    
+    return ui_process
+
+def create_interface():
+    """Создает Gradio интерфейс для редиректа"""
+    with gr.Blocks() as demo:
+        gr.Markdown("# TEN Agent на Hugging Face Space")
+        gr.Markdown("## Загрузка приложения...")
         
-        # Проверяем и создаем директории
-        property_path.parent.mkdir(parents=True, exist_ok=True)
+        # Статус серверов
+        status_md = gr.Markdown("### Статус: Инициализация...")
         
-        # Записываем файл
-        with open(property_path, 'w') as f:
-            json.dump(property_data, f, indent=2)
+        with gr.Row():
+            col1, col2 = gr.Column(), gr.Column()
             
-        print(f"Файл {property_path} создан успешно")
-
-class ProxyHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
-    def do_POST(self):
-        print(f"Получен запрос: {self.path}")
-        
-        # Перенаправляем запрос /api/dev/v1/packages/reload на /graphs
-        if self.path.startswith('/api/dev/v1/packages/reload') or self.path.startswith('/api/designer/v1/packages/reload'):
-            try:
-                print("Перенаправление на /graphs")
-                with urllib.request.urlopen("http://localhost:8080/graphs") as response:
-                    data = response.read()
-                    
-                    # Преобразуем данные для нужного формата
-                    try:
-                        graphs = json.loads(data)
-                        formatted_response = {
-                            "data": graphs,
-                            "status": 200,
-                            "message": "Success"
-                        }
-                        response_data = json.dumps(formatted_response).encode('utf-8')
-                    except:
-                        response_data = data
-                    
-                    # Отправляем ответ
-                    self.send_response(200)
-                    self.send_header('Content-Type', 'application/json')
-                    self.send_header('Content-Length', len(response_data))
-                    self.send_header('Access-Control-Allow-Origin', '*')
-                    self.end_headers()
-                    self.wfile.write(response_data)
-                    print(f"Отправлен ответ: {response_data.decode('utf-8')}")
-            except urllib.error.URLError as e:
-                print(f"Ошибка при перенаправлении: {e}")
-                self.send_error(500, f"Proxy Error: {e}")
-        else:
-            self.send_error(404, "Not Found")
+            with col1:
+                # Кнопка для открытия UI в iframe
+                open_iframe = gr.Button("Показать TEN Agent в iframe")
+                
+                # Функция для открытия UI в iframe
+                def show_iframe():
+                    return f"""
+                    <div style="border: 1px solid #ccc; padding: 10px; border-radius: 5px;">
+                        <iframe src="{UI_URL}" width="100%" height="600px" frameborder="0"></iframe>
+                    </div>
+                    """
+                
+                iframe_area = gr.HTML()
+                open_iframe.click(show_iframe, outputs=iframe_area)
             
-    def do_OPTIONS(self):
-        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 run_proxy_server():
-    """Запускает прокси-сервер на порту 49483"""
-    handler = ProxyHTTPRequestHandler
-    httpd = socketserver.TCPServer(("", 49483), handler)
-    print("Прокси-сервер запущен на порту 49483")
-    httpd.serve_forever()
-
-def check_files():
-    """Проверяет и выводит информацию о важных файлах"""
-    files_to_check = [
-        "/app/agents/property.json",
-        "/app/agents/manifest.json",
-        "/app/agents/voice_agent.json",
-        "/app/agents/chat_agent.json",
-        "/app/server/bin/api"
-    ]
-    
-    print("\n=== Проверка критических файлов ===")
-    for file_path in files_to_check:
-        path = Path(file_path)
-        if path.exists():
-            if path.is_file():
-                size = path.stat().st_size
-                print(f"✅ {file_path} (размер: {size} байт)")
+            with col2:
+                # Ссылка на UI
+                gr.Markdown(f"""
+                ### Открыть TEN Agent в новой вкладке:
                 
-                # Если это JSON файл, выводим его содержимое
-                if file_path.endswith('.json'):
-                    try:
-                        with open(file_path, 'r') as f:
-                            content = json.load(f)
-                        print(f"   Содержимое: {json.dumps(content, indent=2)}")
-                    except Exception as e:
-                        print(f"   Ошибка чтения JSON: {e}")
-            else:
-                print(f"❌ {file_path} (это директория, а не файл)")
-        else:
-            print(f"❌ {file_path} (файл не найден)")
-    
-    print("\n=== Проверка структуры директорий ===")
-    print("Содержимое /app/agents:")
-    subprocess.run(["ls", "-la", "/app/agents"])
-    
-    print("\nПроверка прав доступа:")
-    subprocess.run(["stat", "/app/agents"])
-    subprocess.run(["stat", "/app/agents/property.json"])
-
-def test_api():
-    """Делает запрос к API для получения списка графов"""
-    import urllib.request
-    import urllib.error
+                <a href="{UI_URL}" target="_blank" style="display: inline-block; padding: 10px 15px; background-color: #4CAF50; color: white; text-decoration: none; border-radius: 4px; margin: 10px 0;">Открыть TEN Agent UI</a>
+                
+                ### ВАЖНО:
+                
+                Настройте API ключи в интерфейсе для полноценной работы:
+                - OpenAI API Key
+                - ElevenLabs API Key
+                - Deepgram API Key
+                - Agora App ID и Certificate
+                """)
+        
+        # Статус серверов и логи
+        with gr.Accordion("Системная информация", open=False):
+            api_status = gr.Textbox(label="Статус API сервера", value="Запускается...", interactive=False)
+            ui_status = gr.Textbox(label="Статус UI сервера", value="Запускается...", interactive=False)
+            
+            # Функция обновления статуса
+            def update_status():
+                api_status_msg = "✅ Активен" if is_port_in_use(API_PORT) else "❌ Не активен"
+                ui_status_msg = "✅ Активен" if is_port_in_use(NEXTJS_PORT) else "❌ Не активен"
+                status_md_msg = f"### Статус: {'✅ Все системы работают' if is_port_in_use(API_PORT) and is_port_in_use(NEXTJS_PORT) else '⚠️ Есть проблемы'}"
+                return [api_status_msg, ui_status_msg, status_md_msg]
+            
+            status_btn = gr.Button("Обновить статус")
+            status_btn.click(update_status, outputs=[api_status, ui_status, status_md])
     
-    print("\n=== Тестирование API ===")
-    try:
-        # Даем серверу время запуститься
-        time.sleep(3)
-        with urllib.request.urlopen("http://localhost:8080/graphs") as response:
-            data = response.read().decode('utf-8')
-            print(f"Ответ /graphs: {data}")
-    except urllib.error.URLError as e:
-        print(f"Ошибка запроса к API: {e}")
-    except Exception as e:
-        print(f"Неизвестная ошибка при запросе к API: {e}")
+    return demo
+
+# Вспомогательная функция для проверки, используется ли порт
+def is_port_in_use(port):
+    import socket
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        try:
+            s.connect(('localhost', port))
+            return True
+        except:
+            return False
 
 def main():
-    processes = []
+    # Создаем директории и файлы конфигурации
+    create_directories()
+    create_config_files()
+    
+    # Запускаем API сервер
+    api_process = start_api_server()
+    if not api_process:
+        print("Не у��алось запустить API сервер")
+        return
+    
+    # Запускаем Playground UI
+    ui_process = start_playground()
+    if not ui_process:
+        print("Не удалось запустить Playground UI")
+        api_process.terminate()
+        return
+    
+    # Создаем Gradio интерфейс
+    demo = create_interface()
+    
+    # Запускаем Gradio
+    demo.launch(server_port=GRADIO_PORT, server_name=INTERNAL_HOST, share=False)
+    
+    # Остаемся в цикле до завершения процессов
     try:
-        # Пути к исполняемым файлам
-        api_binary = Path("/app/server/bin/api")
-        playground_dir = Path("/app/playground")
-        
-        # Проверяем существование файлов
-        if not api_binary.exists():
-            print(f"ERROR: API binary not found at {api_binary}", file=sys.stderr)
-            return 1
-        
-        if not playground_dir.exists():
-            print(f"ERROR: Playground directory not found at {playground_dir}", file=sys.stderr)
-            return 1
-        
-        # Проверяем и создаем property.json
-        check_and_create_property_json()
-        
-        # Проверка файлов перед запуском
-        check_files()
-        
-        # Запускаем API сервер
-        print("Starting TEN-Agent API server on port 8080...")
-        api_process = subprocess.Popen([str(api_binary)])
-        processes.append(api_process)
-        
-        # Тестируем API
-        test_thread = threading.Thread(target=test_api)
-        test_thread.daemon = True
-        test_thread.start()
-        
-        # Запускаем прокси-сервер на порту 49483
-        proxy_thread = threading.Thread(target=run_proxy_server)
-        proxy_thread.daemon = True
-        proxy_thread.start()
-        
-        # Запускаем Playground UI в режиме dev на порту 7860 (порт Hugging Face)
-        print("Starting Playground UI in development mode on port 7860...")
-        os.environ["PORT"] = "7860"
-        os.environ["AGENT_SERVER_URL"] = "http://localhost:8080"
-        os.environ["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"  # Включаем расширенный режим редактирования
-        os.environ["NEXT_PUBLIC_DISABLE_CAMERA"] = "true"  # Отключаем запрос на использование камеры
-        
-        playground_process = subprocess.Popen(
-            ["pnpm", "dev"],
-            cwd=str(playground_dir),
-            env=os.environ
-        )
-        processes.append(playground_process)
-        
-        # Ожидаем завершения процессов
-        for proc in processes:
-            proc.wait()
+        while True:
+            if api_process.poll() is not None:
+                print("API сервер остановлен")
+                ui_process.terminate()
+                break
+            
+            if ui_process.poll() is not None:
+                print("UI остановлен")
+                api_process.terminate()
+                break
             
+            time.sleep(1)
     except KeyboardInterrupt:
-        print("Shutting down...")
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-    finally:
-        # Завершение процессов
-        for proc in processes:
-            if proc and proc.poll() is None:
-                proc.terminate()
-                try:
-                    proc.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    proc.kill()
-    
-    return 0
+        print("Принудительная остановка...")
+        api_process.terminate()
+        ui_process.terminate()
 
 if __name__ == "__main__":
     # Корректная обработка сигналов

proxy.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+import http.server
+import socketserver
+import urllib.request
+import urllib.error
+import json
+import os
+import sys
+from pathlib import Path
+
+# Порты для сервисов
+API_PORT = int(os.environ.get("API_PORT", 8080))
+UI_PORT = int(os.environ.get("UI_PORT", 3000))
+PROXY_PORT = int(os.environ.get("PROXY_PORT", 49483))
+
+class ProxyHandler(http.server.SimpleHTTPRequestHandler):
+    def log_message(self, format, *args):
+        """Переопределение логирования для вывода в stdout"""
+        print("%s - %s" % (self.address_string(), format % args))
+        
+    def do_GET(self):
+        """Обработка GET запросов с перенаправлением"""
+        print(f"GET request: {self.path}")
+        
+        # Если путь начинается с /api, перенаправляем на API сервер
+        if self.path.startswith('/api/'):
+            self._proxy_request("GET", API_PORT)
+        else:
+            self.send_error(404, "Not Found")
+            
+    def do_POST(self):
+        """Обработка POST запросов с перенаправлением"""
+        print(f"POST request: {self.path}")
+        
+        # Если путь начинается с /api, перенаправляем на API сервер
+        if self.path.startswith('/api/'):
+            self._proxy_request("POST", API_PORT)
+        elif self.path.startswith('/api/dev/v1/packages') or self.path.startswith('/api/designer/v1/packages'):
+            self._handle_packages_request()
+        else:
+            self.send_error(404, "Not Found")
+            
+    def do_OPTIONS(self):
+        """Обработка OPTIONS запросов"""
+        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, Authorization')
+        self.end_headers()
+        
+    def _proxy_request(self, method, port):
+        """Прокси запрос на указанный порт"""
+        target_url = f"http://localhost:{port}{self.path}"
+        
+        try:
+            # Читаем тело запроса, если есть
+            content_length = int(self.headers['Content-Length']) if 'Content-Length' in self.headers else 0
+            body = self.rfile.read(content_length) if content_length > 0 else None
+            
+            # Создаем запрос
+            req = urllib.request.Request(
+                target_url,
+                data=body,
+                headers={k: v for k, v in self.headers.items() if k.lower() not in ('host', 'content-length')},
+                method=method
+            )
+            
+            # Выполняем запрос
+            with urllib.request.urlopen(req) as response:
+                # Копируем заголовки ответа
+                self.send_response(response.status)
+                for key, val in response.getheaders():
+                    if key.lower() not in ('transfer-encoding', 'content-encoding'):
+                        self.send_header(key, val)
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.end_headers()
+                
+                # Копируем тело ответа
+                self.wfile.write(response.read())
+                
+        except urllib.error.HTTPError as e:
+            self.send_response(e.code)
+            for key, val in e.headers.items():
+                if key.lower() not in ('transfer-encoding', 'content-encoding'):
+                    self.send_header(key, val)
+            self.send_header('Access-Control-Allow-Origin', '*')
+            self.end_headers()
+            self.wfile.write(e.read())
+        except Exception as e:
+            self.send_error(500, f"Proxy Error: {str(e)}")
+            
+    def _handle_packages_request(self):
+        """Обрабатывает запросы к пакетам"""
+        try:
+            # Читаем содержимое property.json
+            property_file = Path("/tmp/ten_user/agents/property.json")
+            if property_file.exists():
+                with open(property_file, 'r') as f:
+                    property_data = json.load(f)
+                    
+                graphs = property_data.get("graphs", [])
+                
+                # Формируем ответ
+                response = {
+                    "data": graphs,
+                    "status": 200,
+                    "message": "Success"
+                }
+                
+                # Отправляем ответ
+                self.send_response(200)
+                self.send_header('Content-Type', 'application/json')
+                self.send_header('Access-Control-Allow-Origin', '*')
+                self.end_headers()
+                
+                self.wfile.write(json.dumps(response).encode('utf-8'))
+            else:
+                self.send_error(404, "Property file not found")
+        except Exception as e:
+            self.send_error(500, f"Error handling packages request: {str(e)}")
+            
+def run_proxy_server():
+    """Запускает прокси-сервер на указанном порту"""
+    handler = ProxyHandler
+    with socketserver.TCPServer(("", PROXY_PORT), handler) as httpd:
+        print(f"Starting proxy server on port {PROXY_PORT}...")
+        httpd.serve_forever()
+        
+if __name__ == "__main__":
+    run_proxy_server() 

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.0
+requests>=2.28.0
+fastapi>=0.100.0
+python-dotenv>=1.0.0
+uvicorn>=0.25.0
+numpy>=1.24.0
+websockets>=12.0 

start.sh

@@ -1,28 +1,50 @@
 #!/bin/bash
 
-# Вывод информации о запуске
-echo "===== Starting TEN-Agent on HuggingFace Space ====="
+echo "===== Starting TEN-Agent in Python Mode ====="
 echo "$(date)"
 echo "Current directory: $(pwd)"
 
-# Вывод информации о пользователе и его правах
-echo "===== Environment Information ====="
-echo "User: $(whoami)"
-echo "Groups: $(groups)"
-echo "Home directory: $HOME"
+# Создаем необходимые директории
+echo "Creating temporary directories in /tmp..."
+mkdir -p /tmp/ten_user/agents
+mkdir -p /tmp/ten_user/logs
+chmod -R 777 /tmp/ten_user
+
+# Проверяем наличие файлов
+echo "Checking necessary files..."
+if [ -f "api_wrapper.py" ]; then
+    echo "✅ api_wrapper.py found"
+else
+    echo "❌ api_wrapper.py missing!"
+    exit 1
+fi
 
-# Проверяем наличие .env файла
-if [ -f .env ]; then
-    echo "✅ .env file found"
-    cat .env | grep -v "KEY\|CERTIFICATE" | sed 's/=.*/=***/'
+if [ -f "app.py" ]; then
+    echo "✅ app.py found"
 else
-    echo "⚠️ Warning: .env file not found, will use environment variables"
+    echo "❌ app.py missing!"
+    exit 1
 fi
 
-# Запускаем приложение напрямую через fallback скрипт
-echo "===== Starting TEN-Agent via fallback script ====="
-echo "Due to permission issues in Hugging Face Space, we'll use the fallback script"
-echo "This will create necessary files in /tmp where we have write access"
+# Убеждаемся, что fallback.py не будет использован
+if [ -f "fallback.py" ]; then
+    echo "⚠️ Renaming fallback.py to fallback.py.bak to prevent conflicts"
+    mv fallback.py fallback.py.bak
+fi
+
+# Выводим информацию об окружении
+echo "===== Environment Information ====="
+echo "User: $(whoami || echo 'Unknown')"
+echo "Home directory: $HOME"
+echo "Python version: $(python3 --version)"
+echo "Node version: $(node --version)"
+
+# Запускаем прокси-сервер в фоновом режиме
+echo "Starting proxy server..."
+python3 proxy.py &
+PROXY_PID=$!
+echo "Proxy server started with PID: $PROXY_PID"
 
-# Выполняем Python скрипт напрямую
-exec python3 /app/fallback.py 
+# Запускаем приложение через Python-обертку
+echo "Starting TEN-Agent via Python wrapper (app.py)..."
+exec python3 app.py