Улучшение работы TEN-Agent на HuggingFace Space

.space/config.json

@@ -0,0 +1,7 @@
+{
+    "docker": {
+        "enable": true,
+        "build": true,
+        "gpu": false
+    }
+}

Dockerfile

@@ -1,56 +1,105 @@
-FROM node:18
+FROM ubuntu:22.04
 
-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-pip \
     python3-venv \
-    git \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
+    python3-pip \
+    python3-dev \
+    unzip \
+    jq \
+    vim \
+    ca-certificates \
+    gnupg \
+    lsb-release \
+    net-tools \
+    procps \
+    && 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
 
-# Копируем файлы API wrapper и конфигурации
-COPY api_wrapper.py /app/
-COPY app.py /app/
-COPY proxy.py /app/
-COPY .space/hf-space.sh /app/
+# Настройка окружения Go
+ENV PATH=$PATH:/usr/local/go/bin
+ENV GOPATH=/go
+ENV PATH=$PATH:$GOPATH/bin
+RUN mkdir -p /go && chmod 777 /go
 
-# Создаем директории
-RUN mkdir -p /tmp/ten_user/agents /tmp/ten_user/logs /app/backup /tmp/ten_playground
-RUN chmod -R 777 /tmp/ten_playground
+# Создание директории для кэша Go
+ENV GOCACHE=/tmp/go-cache
+RUN mkdir -p /tmp/go-cache && chmod 777 /tmp/go-cache
 
-# Создаем и активируем виртуальную среду Python
-RUN python3 -m venv /app/venv
-ENV PATH="/app/venv/bin:$PATH"
+# Установка 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 pip install --no-cache-dir -U pip && \
-    pip install --no-cache-dir -r requirements.txt
+# Клонирование репозитория TEN-Agent
+WORKDIR /app
+RUN git clone --depth 1 https://github.com/TEN-framework/TEN-Agent.git /app-temp && \
+    mv /app-temp/* /app/ && \
+    mv /app-temp/.* /app/ 2>/dev/null || true && \
+    rm -rf /app-temp
 
-# Клонируем репозиторий 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 /tmp/ten_user/agents && chmod 777 /tmp/ten_user/agents
+RUN mkdir -p /tmp/ten_user/logs && chmod 777 /tmp/ten_user/logs
+RUN mkdir -p /tmp/ten_user/rag_data && chmod 777 /tmp/ten_user/rag_data
+RUN mkdir -p /app/backup && chmod 777 /app/backup
 
-# Копируем только необходимые файлы из репозитория
-RUN mkdir -p /app/playground
-RUN cp -r /tmp/ten-agent/playground/* /app/playground/
-RUN rm -rf /tmp/ten-agent
+# Компиляция API сервера (для справки, мы будем использовать Python-реализацию)
+RUN mkdir -p /app/server/bin && \
+    cd /app/server && \
+    GOCACHE=/tmp/go-cache go build -o bin/api main.go && \
+    chmod +x bin/api
 
-# Устанавливаем pnpm и next глобально для использования с npx
-RUN npm install -g pnpm@8 next@latest
+# Проверяем, что API сервер скомпилирован
+RUN ls -la /app/server/bin/api || echo "API server not compiled"
 
-# Возвращаемся в основную директорию
-WORKDIR /app
+# Предварительная установка зависимостей для playground
+# Делаем это отдельно, чтобы не пересобирать при каждом изменении
+RUN cd /app/playground && pnpm install
+
+# Запускаем playground один раз для предварительной сборки
+RUN cd /app/playground && pnpm build || echo "Failed to build playground, but continuing"
+
+# Копируем наши скрипты
+COPY fallback.py /app/fallback.py
+COPY api_wrapper.py /app/api_wrapper.py
+COPY start.sh /app/start.sh
+RUN chmod +x /app/start.sh /app/fallback.py /app/api_wrapper.py
+
+# Устанавливаем переменные окружения для HuggingFace
+ENV HF_SPACE=true
+ENV AGENT_SERVER_URL=http://localhost:8080
+ENV NEXT_PUBLIC_EDIT_GRAPH_MODE=true
+ENV NEXT_PUBLIC_DISABLE_CAMERA=true
+ENV PORT=7860
+ENV API_PORT=8080
+ENV TEN_AGENT_DIR=/tmp/ten_user/agents
+ENV PYTHONUNBUFFERED=1
 
-# Делаем скрипт запуска исполняемым
-RUN chmod +x /app/hf-space.sh
+# Открываем порты (7860 для HF Space, 8080 для API)
+EXPOSE 7860 8080
 
-# Экспортируем порт
-EXPOSE 7860 3000 8080
+# Предварительно создаем важные файлы
+RUN mkdir -p /app/agents
+RUN echo '{"_ten":{"version":"0.0.1"},"name":"default","agents":[{"name":"voice_agent","description":"A simple voice agent","type":"voice"}]}' > /app/agents/manifest.json
+RUN echo '{"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"}]}' > /app/agents/property.json
 
-# Запускаем приложение через скрипт
-COPY start.sh /app/
-RUN chmod +x /app/start.sh
+# Запускаем TEN-Agent через fallback скрипт
 CMD ["/app/start.sh"]

api_wrapper.py

@@ -3,317 +3,204 @@ import http.server
 import json
 import os
 import sys
-import logging
+import datetime
+import traceback
 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:
-    # В HuggingFace используем корневую директорию /tmp
-    TMP_DIR = os.environ.get("TMP_DIR", "/tmp")
-    AGENT_DIR = os.environ.get("TEN_AGENT_DIR", TMP_DIR)
-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}")
-
-# Проверяем наличие файлов конфигурации
-agent_dir_path = Path(AGENT_DIR)
-if agent_dir_path.exists():
-    logger.info(f"Checking files in agent directory {AGENT_DIR}:")
-    for file in agent_dir_path.iterdir():
-        if file.name.endswith('.json'):
-            logger.info(f"  - {file.name} ({os.path.getsize(file)}b)")
-else:
-    logger.warning(f"Agent directory {AGENT_DIR} does not exist!")
+AGENT_DIR = os.environ.get("TEN_AGENT_DIR", "/tmp/ten_user/agents")
 
 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.send_header('Access-Control-Allow-Headers', 'Content-Type, X-Requested-With')
         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)
+    def log_request(self, code='-', size='-'):
+        # Переопределяем, чтобы не логировать каждый запрос в stderr
+        # особенно health checks, которые могут забивать логи
+        if self.path != '/health':
+            super().log_request(code, size)
         
-        # Обрабатываем 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):
-        """Обработка запроса на получение списка графов"""
+    def do_GET(self):
         try:
-            property_file = Path(AGENT_DIR) / "property.json"
-            logger.info(f"Looking for property file at {property_file}")
+            print(f"GET request: {self.path}")
             
-            if not property_file.exists():
-                logger.error(f"Property file not found at {property_file}")
-                
-                # Проверяем, возможно файл находится в другой директории
-                alt_property_file = Path("/tmp/property.json")
-                if alt_property_file.exists():
-                    logger.info(f"Found property file at alternative location: {alt_property_file}")
-                    property_file = alt_property_file
-                else:
-                    self.send_error(404, "Property file not found")
-                    return
-            
-            with open(property_file, "r") as f:
-                property_data = json.load(f)
+            # Базовые API эндпоинты
+            if self.path in ["/graphs", "/api/graphs"]:
+                # Чтение property.json для получения списка графов
+                try:
+                    property_file = Path(AGENT_DIR) / "property.json"
+                    if not property_file.exists():
+                        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())
+                except Exception as e:
+                    print(f"Error reading property.json: {e}")
+                    self.send_error(500, f"Internal error: {e}")
             
-            graphs = property_data.get("graphs", [])
-            
-            # Для каждого графа проверяем наличие файла
-            for graph in graphs:
-                file_name = graph.get("file", "")
-                file_path = Path(AGENT_DIR) / file_name
-                alt_file_path = Path("/tmp") / file_name
+            elif self.path in ["/health", "/"]:
+                # Просто возвращаем, что API сервер работает
+                self._set_headers()
+                self.wfile.write(json.dumps({
+                    "status": "ok",
+                    "time": str(datetime.datetime.now()),
+                    "message": "TEN Agent API wrapper is running"
+                }).encode())
+                
+            elif self.path == "/list":
+                # Возвращаем пустой список сессий
+                self._set_headers()
+                self.wfile.write(json.dumps([]).encode())
                 
-                if file_path.exists():
-                    logger.info(f"Graph file exists: {file_path}")
-                elif alt_file_path.exists():
-                    logger.info(f"Graph file exists at alternative location: {alt_file_path}")
-                else:
-                    logger.warning(f"Graph file not found: {file_name}")
+            elif self.path.startswith("/dev-tmp/"):
+                # Обработка всех запросов к /dev-tmp/
+                self._set_headers()
+                self.wfile.write(json.dumps({}).encode())
+                
+            elif self.path == "/vector/document/preset/list":
+                # Возвращаем пустой список предустановок векторов
+                self._set_headers()
+                self.wfile.write(json.dumps([]).encode())
             
-            self._set_headers()
-            self.wfile.write(json.dumps(graphs).encode())
-            logger.info(f"Returned {len(graphs)} graphs")
+            # Обработка запросов к API TEN Graph Designer
+            elif self.path.startswith("/api/designer/") or self.path.startswith("/api/dev/"):
+                self._set_headers()
+                self.wfile.write(json.dumps({"data": [], "status": 200, "message": "Success"}).encode())
+                
+            else:
+                # Для всех остальных запросов возвращаем 404
+                self.send_error(404, "Not found")
         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,
-            "agent_dir": AGENT_DIR
-        }).encode())
+            print(f"Error handling GET request: {e}")
+            traceback.print_exc()
+            self.send_error(500, f"Internal server error: {e}")
     
-    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):
-        """Обработка запросов к пакетам"""
-        # Этот метод эмулирует возврат списка графов и для других эндпоинтов
+    def do_POST(self):
         try:
-            property_file = Path(AGENT_DIR) / "property.json"
-            if not property_file.exists():
-                # Проверяем альтернативную директорию
-                alt_property_file = Path("/tmp/property.json")
-                if alt_property_file.exists():
-                    property_file = alt_property_file
-                else:
-                    logger.error(f"Property file not found at {property_file}")
-                    self.send_error(404, "Property file not found")
-                    return
+            print(f"POST request: {self.path}")
             
-            with open(property_file, "r") as f:
-                property_data = json.load(f)
+            # Читаем тело запроса
+            content_length = int(self.headers['Content-Length']) if 'Content-Length' in self.headers else 0
+            post_data = self.rfile.read(content_length)
             
-            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 = {}
+            try:
+                request_data = json.loads(post_data) if content_length > 0 else {}
+            except json.JSONDecodeError:
+                request_data = {}
+                
+            print(f"Request data: {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,
-            "agent_dir": AGENT_DIR
-        }).encode())
+            if self.path == "/ping":
+                # Для ping запросов просто возвращаем успешный статус
+                self._set_headers()
+                self.wfile.write(json.dumps({"status": "ok"}).encode())
+                
+            elif self.path == "/token/generate":
+                # Для запросов на генерацию токена возвращаем простой токен
+                # Это нужно для Agora SDK
+                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())
+                
+            elif self.path == "/start":
+                # Для запросов на запуск сессии возвращаем успешный статус
+                self._set_headers()
+                # Возвращаем идентификатор сессии для совместимости
+                session_id = "fallback-session-" + datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+                self.wfile.write(json.dumps({
+                    "status": "ok", 
+                    "session_id": session_id
+                }).encode())
+                
+            elif self.path == "/stop":
+                # Для запросов на остановку сессии возвращаем успешный статус
+                self._set_headers()
+                self.wfile.write(json.dumps({"status": "ok"}).encode())
+                
+            elif self.path.startswith("/vector/document/"):
+                # Для запросов на обновление или загрузку документов возвращаем успешный статус
+                self._set_headers()
+                self.wfile.write(json.dumps({"status": "ok", "message": "Operation completed"}).encode())
+                
+            # API для TEN Graph Designer
+            elif self.path.startswith("/api/designer/") or self.path.startswith("/api/dev/"):
+                self._set_headers()
+                self.wfile.write(json.dumps({"data": {}, "status": 200, "message": "Success"}).encode())
+                
+            else:
+                # Для всех остальных запросов возвращаем 404
+                self.send_error(404, "Not found")
+        except Exception as e:
+            print(f"Error handling POST request: {e}")
+            traceback.print_exc()
+            self.send_error(500, f"Internal server error: {e}")
+
+def run(server_class=http.server.HTTPServer, handler_class=TENAgentHandler, port=8080):
+    server_address = ('', port)
+    httpd = server_class(server_address, handler_class)
+    print(f"Starting API server on port {port}...")
+    print(f"Using agent directory: {AGENT_DIR}")
     
-    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', '')}")
+    # Проверяем, что директория с агентами существует
+    agent_dir_path = Path(AGENT_DIR)
+    if not agent_dir_path.exists():
+        print(f"WARNING: Agent directory {AGENT_DIR} does not exist, creating it...")
+        agent_dir_path.mkdir(exist_ok=True, parents=True)
     
-    def _handle_start(self, request_data):
-        """Обработка запроса на запуск сессии"""
-        graph_file = request_data.get("graph_file", "")
-        logger.info(f"Starting session with graph file: {graph_file}")
-        
-        # Проверяем наличие файла графа
-        graph_path = Path(AGENT_DIR) / graph_file
-        alt_graph_path = Path("/tmp") / graph_file
+    # Проверка наличия необходимых файлов
+    property_file = agent_dir_path / "property.json"
+    if not property_file.exists():
+        print(f"WARNING: property.json not found in {AGENT_DIR}")
+        print("Creating minimal property.json...")
         
-        if graph_path.exists():
-            logger.info(f"Found graph file at: {graph_path}")
-        elif alt_graph_path.exists():
-            logger.info(f"Found graph file at alternative location: {alt_graph_path}")
-        else:
-            logger.warning(f"Graph file not found: {graph_file}")
-        
-        self._set_headers()
-        # Возвращаем успешный статус и ID сессии
-        response = {
-            "status": "ok",
-            "session_id": f"dummy_session_{int(time.time())}",
-            "message": "Session started successfully",
-            "graph_file": graph_file
+        # Создаем базовый property.json
+        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"
+                }
+            ]
         }
-        self.wfile.write(json.dumps(response).encode())
-        logger.info(f"Started session with graph: {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')}")
+        
+        try:
+            with open(property_file, "w") as f:
+                json.dump(property_data, f, indent=2)
+            print(f"Created {property_file}")
+        except Exception as e:
+            print(f"ERROR: Could not create property.json: {e}")
     
-    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")
+        print("Shutting down API server...")
     except Exception as e:
-        logger.error(f"Server error: {e}")
-        raise
+        print(f"Error in API server: {e}")
+        traceback.print_exc()
 
 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}") 
+    run(port=port) 

fallback.py

@@ -6,6 +6,9 @@ import sys
 import time
 import shutil
 from pathlib import Path
+import threading
+import urllib.request
+import urllib.error
 
 def create_user_directory():
     """Создает отдельную директорию для пользовательских файлов"""
@@ -29,8 +32,12 @@ def create_user_directory():
     go_cache_dir = Path("/tmp/go-cache")
     go_cache_dir.mkdir(exist_ok=True, parents=True)
     
+    # Создаем директорию для RAG данных
+    rag_dir = user_dir / "rag_data"
+    rag_dir.mkdir(exist_ok=True, parents=True)
+    
     print(f"Created directory structure at {user_dir}")
-    return user_dir, agents_dir, server_bin_dir, logs_dir, go_cache_dir
+    return user_dir, agents_dir, server_bin_dir, logs_dir, go_cache_dir, rag_dir
 
 def create_basic_files(agents_dir):
     """Создает базовые файлы конфигурации для TEN-Agent"""
@@ -137,54 +144,53 @@ def create_basic_files(agents_dir):
     
     print("Basic configuration files created successfully.")
 
-def copy_api_server(server_bin_dir):
-    """Копирует предварительно скомпилированный API сервер"""
-    api_bin = server_bin_dir / "api"
-    
-    # Приоритезируем API сервер из директории fallback
-    fallback_bin = Path("/app/fallback/api")
-    if fallback_bin.exists():
-        print(f"Found pre-compiled API server at {fallback_bin}")
-        shutil.copy(fallback_bin, api_bin)
-        api_bin.chmod(0o755)  # Делаем исполняемым
-        print(f"API server binary copied to {api_bin}")
-        return True
-    
-    # Ищем API сервер в основной директории
-    original_bin = Path("/app/server/bin/api")
-    if original_bin.exists():
-        print(f"Found API server at {original_bin}")
-        shutil.copy(original_bin, api_bin)
-        api_bin.chmod(0o755)  # Делаем исполняемым
-        print(f"API server binary copied to {api_bin}")
-        return True
-    
-    # Если не нашли готовый бинарник, пытаемся компилировать
+def check_file_permissions(filepath):
+    """Проверяет и выводит права доступа для файла"""
     try:
-        print("No pre-compiled API server found, trying to compile from source...")
-        env = os.environ.copy()
-        env["GOCACHE"] = "/tmp/go-cache"  # Указываем директорию для кэша Go
-        env["GOPATH"] = "/tmp/go-path"  # Указываем пользовательский GOPATH
+        print(f"Checking permissions for {filepath}")
+        if not Path(filepath).exists():
+            print(f"  - File does not exist!")
+            return
         
-        # Создаем директорию для GOPATH
-        Path("/tmp/go-path").mkdir(exist_ok=True, parents=True)
+        # Получаем права доступа и информацию о файле
+        result = subprocess.run(["ls", "-la", filepath], capture_output=True, text=True)
+        if result.returncode == 0:
+            print(f"  - {result.stdout.strip()}")
+        else:
+            print(f"  - Error: {result.stderr.strip()}")
+            
+        # Проверяем, можем ли писать в файл
+        try:
+            with open(filepath, "a") as f:
+                pass
+            print("  - Can write: Yes")
+        except PermissionError:
+            print("  - Can write: No (Permission denied)")
+        except Exception as e:
+            print(f"  - Can write: No ({e})")
+    except Exception as e:
+        print(f"Error checking permissions: {e}")
+
+def test_api_connection(max_attempts=5):
+    """Проверяет, доступен ли API сервер"""
+    print("\nTesting API server connection...")
+    for attempt in range(max_attempts):
+        try:
+            with urllib.request.urlopen("http://localhost:8080/health") as response:
+                if response.status == 200:
+                    print(f"✅ API server is working! Response: {response.read().decode()}")
+                    return True
+                else:
+                    print(f"❌ API server responded with status {response.status}")
+        except Exception as e:
+            print(f"❌ Attempt {attempt+1}/{max_attempts}: API server connection failed: {e}")
         
-        # Компилируем с пользовательскими настройками
-        result = subprocess.run(
-            "cd /app/server && go build -o /tmp/ten_user/server/bin/api main.go",
-            shell=True,
-            check=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            env=env
-        )
-        print(f"Successfully compiled API server: {result.stdout.decode()}")
-        api_bin.chmod(0o755)
-        return True
-    except subprocess.CalledProcessError as e:
-        print(f"Failed to compile API server: {e.stderr.decode()}")
-        print("Critical error: No API server available!")
-        return False
+        if attempt < max_attempts - 1:
+            print(f"Waiting 2 seconds before next attempt...")
+            time.sleep(2)
+    
+    print("Could not connect to API server after multiple attempts")
+    return False
 
 def main():
     try:
@@ -197,8 +203,11 @@ def main():
         print(f"HOME: {os.environ.get('HOME', 'unset')}")
         print(f"PATH: {os.environ.get('PATH', 'unset')}")
         
+        # Проверяем наличие /tmp и права на него
+        check_file_permissions("/tmp")
+        
         # Создаем пользовательские директории
-        user_dir, agents_dir, server_bin_dir, logs_dir, go_cache_dir = create_user_directory()
+        user_dir, agents_dir, server_bin_dir, logs_dir, go_cache_dir, rag_dir = create_user_directory()
         
         # Создаем пустой файл в директории логов, чтобы точно создать директорию
         (logs_dir / "server.log").touch()
@@ -207,98 +216,61 @@ def main():
         # Создаем базовые конфигурационные файлы
         create_basic_files(agents_dir)
         
-        # Копируем API сервер
-        if not copy_api_server(server_bin_dir):
-            print("Critical error: Cannot prepare API server")
-            sys.exit(1)
-        
-        # Проверяем, что API сервер действительно скопирован и исполняемый
-        api_bin = server_bin_dir / "api"
-        if not api_bin.exists():
-            print(f"Critical error: API server binary not found at {api_bin}")
-            sys.exit(1)
-            
-        try:
-            api_bin.chmod(0o755)  # Дополнительно проверяем права
-        except Exception as e:
-            print(f"Warning: Could not set execute permissions on API server binary: {e}")
-            # Продолжаем, возможно, права уже установлены
-        
-        print(f"API server binary prepared successfully: {api_bin}")
-        print(f"File exists: {api_bin.exists()}, size: {api_bin.stat().st_size} bytes")
-        
-        # Установка переменных среды
+        # Установка переменных среды для Playground
         os.environ["PORT"] = "7860"  # HuggingFace использует порт 7860
         os.environ["AGENT_SERVER_URL"] = "http://localhost:8080"
         os.environ["NEXT_PUBLIC_EDIT_GRAPH_MODE"] = "true"
         os.environ["NEXT_PUBLIC_DISABLE_CAMERA"] = "true"
+        os.environ["TEN_AGENT_DIR"] = str(agents_dir)
         
-        # Путь к бинарнику API сервера
-        api_bin_str = str(api_bin)
-        
-        # Запускаем API сервер с указанием пути к agents директории
+        # Запускаем API сервер с использованием нашей обертки
         print(f"Starting API server with agents directory: {agents_dir}")
         api_env = os.environ.copy()
         api_env["TEN_AGENT_DIR"] = str(agents_dir)
-        api_env["GOCACHE"] = str(go_cache_dir)  # Устанавливаем переменную GOCACHE
-        
-        # Отключаем логирование в файл
-        api_env["GF_LOG_MODE"] = "console"  # Логирование только в консоль
-        api_env["LOG_LEVEL"] = "error"      # Минимальный уровень логирования
-        api_env["TEN_LOG_DISABLE_FILE"] = "true"  # Отключаем логирование в файл (кастомная переменная)
-        api_env["GF_LOG_FILE_STAT"] = "false"  # Отключаем статистику файлов логов
-        
-        # Выводим важные переменные окружения
-        print(f"Environment variables:")
-        print(f"TEN_AGENT_DIR: {api_env.get('TEN_AGENT_DIR')}")
-        print(f"GF_LOG_MODE: {api_env.get('GF_LOG_MODE')}")
-        print(f"LOG_LEVEL: {api_env.get('LOG_LEVEL')}")
-        print(f"TEN_LOG_DISABLE_FILE: {api_env.get('TEN_LOG_DISABLE_FILE')}")
-        print(f"GOCACHE: {api_env.get('GOCACHE')}")
         
-        # Дополнительно проверяем права на исполнение через ls -la
-        subprocess.run(["ls", "-la", api_bin_str], check=True)
-        
-        # Проверяем директорию логов
-        subprocess.run(["ls", "-la", str(logs_dir)], check=True)
-        
-        # Запускаем API сервер с передачей аргумента для отключения файлового логирования
-        print(f"Executing API server: {api_bin_str}")
-        try:
-            api_process = subprocess.Popen(
-                [api_bin_str, "--log_to_stdout", "--disable_file_logging"],
-                env=api_env,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-        except Exception as e:
-            print(f"Failed to start API server: {e}")
+        # Проверяем наличие API wrapper
+        wrapper_path = Path("/app/api_wrapper.py")
+        if not wrapper_path.exists():
+            print(f"Error: API wrapper not found at {wrapper_path}")
             sys.exit(1)
+            
+        # Убедимся, что у скрипта есть права на исполнение
+        wrapper_path.chmod(0o755)
         
-        # Даем серверу время для запуска и выводим любые ошибки сразу
+        # Запускаем API обертку
+        print(f"Using Python API wrapper instead of original server")
+        api_process = subprocess.Popen(
+            ["python3", str(wrapper_path)],
+            env=api_env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE
+        )
+        
+        # Даем серверу время для запуска
         time.sleep(2)
         
         # Проверяем, запустился ли сервер
         if api_process.poll() is not None:
             print("API server failed to start!")
             stdout, stderr = api_process.communicate()
-            print(f"STDOUT: {stdout.decode()}")
-            print(f"STDERR: {stderr.decode()}")
+            print(f"STDOUT: {stdout.decode() if stdout else 'No output'}")
+            print(f"STDERR: {stderr.decode() if stderr else 'No error output'}")
             sys.exit(1)
         
         # Проверяем доступность API
         print("Testing API server availability...")
-        try:
-            import urllib.request
-            response = urllib.request.urlopen("http://localhost:8080/graphs")
-            print(f"API server is responding! Response: {response.read().decode()}")
-        except Exception as e:
-            print(f"API server is not responding yet, but continuing... ({e})")
-        
-        print("API server started successfully")
+        api_success = test_api_connection()
         
+        if not api_success:
+            print("WARNING: API server may not be working correctly!")
+            
         # Запускаем playground
         print("Starting Playground UI...")
+        playground_path = Path("/app/playground")
+        if not playground_path.exists():
+            print(f"Error: Playground directory not found at {playground_path}")
+            sys.exit(1)
+            
         playground_process = subprocess.Popen(
             "cd /app/playground && pnpm dev",
             env=os.environ,
@@ -314,8 +286,8 @@ def main():
         if playground_process.poll() is not None:
             print("Playground UI failed to start!")
             stdout, stderr = playground_process.communicate()
-            print(f"STDOUT: {stdout.decode()}")
-            print(f"STDERR: {stderr.decode()}")
+            print(f"STDOUT: {stdout.decode() if stdout else 'No output'}")
+            print(f"STDERR: {stderr.decode() if stderr else 'No error output'}")
             
             # Останавливаем API сервер
             api_process.terminate()
@@ -358,8 +330,9 @@ def main():
         
     except Exception as e:
         print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()
         sys.exit(1)
 
 if __name__ == "__main__":
-    import threading
     main() 

start.sh

@@ -1,67 +1,86 @@
 #!/bin/bash
 
-echo "===== Starting TEN-Agent in Python Mode ====="
+# Вывод информации о запуске
+echo "===== Starting TEN-Agent on HuggingFace Space ====="
 echo "$(date)"
 echo "Current directory: $(pwd)"
 
-# Активируем виртуальную среду Python, если она существует
-if [ -d "/app/venv" ]; then
-    echo "Activating Python virtual environment..."
-    source /app/venv/bin/activate
-    PYTHON_CMD="python"
+# Вывод информации о пользователе и его правах
+echo "===== Environment Information ====="
+echo "User: $(whoami)"
+echo "Groups: $(groups)"
+echo "Home directory: $HOME"
+
+# Checking directory permissions
+echo "===== Checking Directory Permissions ====="
+echo "Temp directory permissions:"
+ls -la /tmp
+echo "App directory permissions:"
+ls -la /app
+
+# Проверяем наличие .env файла
+if [ -f .env ]; then
+    echo "✅ .env file found"
+    cat .env | grep -v "KEY\|CERTIFICATE\|PASSWORD\|SECRET" | sed 's/=.*/=***/'
 else
-    echo "No virtual environment found, using system Python..."
-    PYTHON_CMD="python3"
+    echo "⚠️ Warning: .env file not found, will use environment variables"
 fi
 
-# Создаем необходимые директории без изменения прав
-echo "Creating temporary directories in /tmp..."
+# Создаем директории, которые могут понадобиться
+echo "===== Creating required directories ====="
+mkdir -p /tmp/ten_user
 mkdir -p /tmp/ten_user/agents
 mkdir -p /tmp/ten_user/logs
-mkdir -p /tmp/ten_playground
+mkdir -p /tmp/ten_user/rag_data
+chmod -R 755 /tmp/ten_user
 
-# Проверяем, что директории созданы
-echo "Checking directories..."
-if [ -d "/tmp/ten_user" ]; then
-    echo "✅ /tmp/ten_user exists"
+# Проверяем, создаются ли файлы в /tmp
+echo "===== Testing file creation in /tmp ====="
+TEST_FILE="/tmp/test_write_$(date +%s).txt"
+if touch $TEST_FILE; then
+    echo "✅ Can create files in /tmp"
+    echo "Test content" > $TEST_FILE
+    cat $TEST_FILE
+    rm $TEST_FILE
+else
+    echo "❌ Cannot create files in /tmp - this will cause problems!"
 fi
 
-# Проверяем наличие файлов
-echo "Checking necessary files..."
-if [ -f "api_wrapper.py" ]; then
-    echo "✅ api_wrapper.py found"
+# Проверяем наличие необходимых компонентов
+echo "===== Checking required components ====="
+if [ -f /app/fallback.py ]; then
+    echo "✅ Fallback script found"
 else
-    echo "❌ api_wrapper.py missing!"
-    exit 1
+    echo "❌ Fallback script missing!"
 fi
 
-if [ -f "app.py" ]; then
-    echo "✅ app.py found"
+if [ -f /app/api_wrapper.py ]; then
+    echo "✅ API wrapper found"
 else
-    echo "❌ app.py missing!"
-    exit 1
+    echo "❌ API wrapper missing!"
 fi
 
-# Убеждаемся, что fallback.py не будет использован
-if [ -f "fallback.py" ]; then
-    echo "⚠️ Renaming fallback.py to fallback.py.bak to prevent conflicts"
-    mv fallback.py fallback.py.bak
+if [ -d /app/playground ]; then
+    echo "✅ Playground directory found"
+    ls -la /app/playground
+else
+    echo "❌ Playground directory missing!"
 fi
 
-# Выводим информацию об окружении
-echo "===== Environment Information ====="
-echo "User: $(whoami || echo 'Unknown')"
-echo "Home directory: $HOME"
-echo "Python version: $($PYTHON_CMD --version)"
-echo "Node version: $(node --version)"
-echo "Using Python command: $PYTHON_CMD"
+# Запускаем приложение через 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"
 
-# Запускаем прокси-сервер в фоновом режиме
-echo "Starting proxy server..."
-$PYTHON_CMD proxy.py &
-PROXY_PID=$!
-echo "Proxy server started with PID: $PROXY_PID"
+# Установка переменных окружения для совместимости
+export HF_SPACE=true
+export INTERFACE_PORT=7860
+export API_PORT=8080
+export TEN_AGENT_DIR=/tmp/ten_user/agents
+export AGENT_SERVER_URL=http://localhost:8080
+export NEXT_PUBLIC_EDIT_GRAPH_MODE=true
+export NEXT_PUBLIC_DISABLE_CAMERA=true
+export PYTHONUNBUFFERED=1
 
-# Запускаем приложение через Python-обертку
-echo "Starting TEN-Agent via Python wrapper (app.py)..."
-exec $PYTHON_CMD app.py 
+# Выполняем Python скрипт напрямую
+exec python3 /app/fallback.py