Update

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "external/lerobot"]
+	path = external/lerobot
+	url = https://github.com/huggingface/lerobot
+[submodule "external/RobotHub-TransportServer"]
+	path = external/RobotHub-TransportServer
+	url = https://github.com/julien-blanchon/RobotHub-TransportServer

Dockerfile

@@ -0,0 +1,64 @@
+# Use official UV base image with Python 3.12
+FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim
+
+# Set environment variables for Python
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    UV_SYSTEM_PYTHON=1 \
+    UV_CACHE_DIR=/tmp/uv-cache
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    # Build tools for compiling Python packages
+    build-essential \
+    gcc \
+    g++ \
+    # Essential system libraries
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    # FFmpeg for video processing
+    ffmpeg \
+    # Git for potential model downloads
+    git \
+    # Clean up
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user
+RUN groupadd -r appuser && useradd -r -g appuser -m -s /bin/bash appuser
+
+# Set working directory
+WORKDIR /app
+
+# Copy dependency files
+COPY --chown=appuser:appuser pyproject.toml ./
+
+# Copy the external python client dependency
+COPY --chown=appuser:appuser external/ ./external/
+
+# Install Python dependencies (without --frozen to regenerate lock)
+RUN --mount=type=cache,target=/tmp/uv-cache \
+    uv sync --no-dev
+
+# Copy the entire project
+COPY --chown=appuser:appuser . .
+
+# Switch to non-root user
+USER appuser
+
+# Add virtual environment to PATH
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Expose port 7860 (HuggingFace Spaces default)
+EXPOSE 7860
+
+# Health check using activated virtual environment (FastAPI health endpoint)
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:7860/api/health')" || exit 1
+
+# Run the application with activated virtual environment
+CMD ["python", "launch_simple.py", "--host", "0.0.0.0", "--port", "7860"] 

README.md

@@ -0,0 +1,317 @@
+---
+title: LeRobot Arena - AI Inference Server
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+suggested_hardware: t4-small
+suggested_storage: medium
+short_description: Real-time ACT model inference server for robot control
+tags:
+  - robotics
+  - ai
+  - inference
+  - control
+  - act-model
+  - transformer
+  - real-time
+  - gradio
+  - fastapi
+  - computer-vision
+pinned: false
+fullWidth: true
+---
+
+# Inference Server
+
+🤖 **Real-time ACT Model Inference Server for Robot Control**
+
+This server provides ACT (Action Chunking Transformer) model inference for robotics applications using the transport server communication system. It includes a user-friendly Gradio web interface for easy setup and management.
+
+## ✨ Features
+
+- **Real-time AI Inference**: Run ACT models for robot control at 20Hz control frequency
+- **Multi-Camera Support**: Handle multiple camera streams with different names
+- **Web Interface**: User-friendly Gradio UI for setup and monitoring
+- **Session Management**: Create, start, stop, and monitor inference sessions
+- **Automatic Timeout**: Sessions automatically cleanup after 10 minutes of inactivity
+- **Debug Tools**: Built-in debugging and monitoring endpoints
+- **Flexible Configuration**: Support for custom model paths, camera configurations
+- **No External Dependencies**: Direct Python execution without subprocess calls
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.12+
+- UV package manager (recommended)
+- Trained ACT model
+- Transport server running
+
+### 1. Installation
+
+```bash
+cd backend/ai-server
+
+# Install dependencies using uv (recommended)
+uv sync
+
+# Or using pip
+pip install -e .
+```
+
+### 2. Launch the Application
+
+#### **🚀 Simple Integrated Mode (Recommended)**
+```bash
+# Everything runs in one process - no subprocess issues!
+python launch_simple.py
+
+# Or using the CLI
+python -m inference_server.cli --simple
+```
+
+This will:
+- Run everything on `http://localhost:7860`
+- Direct session management (no HTTP API calls)
+- No external subprocess dependencies
+- Most robust and simple deployment!
+
+#### **🔧 Development Mode (Separate Processes)**
+```bash
+# Traditional approach with separate server and UI
+python -m inference_server.cli
+```
+
+This will:
+- Start the AI server on `http://localhost:8001`
+- Launch the Gradio UI on `http://localhost:7860`
+- Better for development and debugging
+
+### 3. Using the Web Interface
+
+1. **Check Server Status**: The interface will automatically check if the AI server is running
+2. **Configure Your Robot**: Enter your model path and camera setup
+3. **Create & Start Session**: Click the button to set up AI control
+4. **Monitor Performance**: Use the status panel to monitor inference
+
+## 🎯 Workflow Guide
+
+### Step 1: AI Server
+- The server status will be displayed at the top
+- Click "Start Server" if it's not already running
+- Use "Check Status" to verify connectivity
+
+### Step 2: Set Up Robot AI
+- **Session Name**: Give your session a unique name (e.g., "my-robot-01")
+- **AI Model Path**: Path to your trained ACT model (e.g., "./checkpoints/act_so101_beyond")
+- **Camera Names**: Comma-separated list of camera names (e.g., "front,wrist,overhead")
+- Click "Create & Start AI Control" to begin
+
+### Step 3: Control Session
+- The session ID will be auto-filled after creation
+- Use Start/Stop buttons to control inference
+- Click "Status" to see detailed performance metrics
+
+## 🛠️ Advanced Usage
+
+### CLI Options
+
+```bash
+# Simple integrated mode (recommended)
+python -m inference_server.cli --simple
+
+# Development mode (separate processes)
+python -m inference_server.cli
+
+# Launch only the server
+python -m inference_server.cli --server-only
+
+# Launch only the UI (server must be running separately)  
+python -m inference_server.cli --ui-only
+
+# Custom ports
+python -m inference_server.cli --server-port 8002 --ui-port 7861
+
+# Enable public sharing
+python -m inference_server.cli --share
+
+# For deployment (recommended)
+python -m inference_server.cli --simple --host 0.0.0.0 --share
+```
+
+### API Endpoints
+
+The server provides a REST API for programmatic access:
+
+- `GET /health` - Server health check
+- `POST /sessions` - Create new session
+- `GET /sessions` - List all sessions
+- `GET /sessions/{id}` - Get session details
+- `POST /sessions/{id}/start` - Start inference
+- `POST /sessions/{id}/stop` - Stop inference
+- `POST /sessions/{id}/restart` - Restart inference
+- `DELETE /sessions/{id}` - Delete session
+
+#### Debug Endpoints
+- `GET /debug/system` - System information (CPU, memory, GPU)
+- `GET /debug/sessions/{id}/queue` - Action queue details
+- `POST /debug/sessions/{id}/reset` - Reset session state
+
+### Configuration
+
+#### Joint Value Convention
+- All joint inputs/outputs use **NORMALIZED VALUES**
+- Most joints: -100 to +100 (RANGE_M100_100)
+- Gripper: 0 to 100 (RANGE_0_100)
+- This matches the training data format exactly
+
+#### Camera Support
+- Supports arbitrary number of camera streams
+- Each camera has a unique name (e.g., "front", "wrist", "overhead")
+- All camera streams are synchronized for inference
+- Images expected in RGB format, uint8 [0-255]
+
+## 📊 Monitoring
+
+### Session Status Indicators
+- 🟢 **Running**: Inference active and processing
+- 🟡 **Ready**: Session created but inference not started
+- 🔴 **Stopped**: Inference stopped
+- 🟠 **Initializing**: Session being set up
+
+### Smart Session Control
+The UI now provides intelligent feedback:
+- ℹ️ **Already Running**: When trying to start a running session
+- ℹ️ **Already Stopped**: When trying to stop a stopped session
+- 💡 **Smart Suggestions**: Context-aware tips based on current status
+
+### Performance Metrics
+- **Inferences**: Total number of model inferences performed
+- **Commands Sent**: Joint commands sent to robot
+- **Queue Length**: Actions waiting in the queue
+- **Errors**: Number of errors encountered
+- **Data Flow**: Images and joint states received
+
+## 🐳 Docker Usage
+
+### Build the Image
+```bash
+cd services/inference-server
+docker build -t inference-server .
+```
+
+### Run the Container
+```bash
+# Basic usage
+docker run -p 7860:7860 inference-server
+
+# With environment variables
+docker run -p 7860:7860 \
+  -e DEFAULT_ARENA_SERVER_URL=http://your-server.com \
+  -e DEFAULT_MODEL_PATH=./checkpoints/your-model \
+  inference-server
+
+# With GPU support
+docker run --gpus all -p 7860:7860 inference-server
+```
+
+## 🔧 Troubleshooting
+
+
+
+### Common Issues
+
+1. **Server Won't Start**
+   - Check if port 8001 is available
+   - Verify model path exists and is accessible
+   - Check dependencies are installed correctly
+
+2. **Session Creation Fails**
+   - Verify model path is correct
+   - Check Arena server is running on specified URL
+   - Ensure camera names match your robot configuration
+
+3. **Poor Performance**
+   - Monitor system resources in the debug panel
+   - Check if GPU is being used for inference
+   - Verify control/inference frequency settings
+
+4. **Connection Issues**
+   - Verify Arena server URL is correct
+   - Check network connectivity
+   - Ensure workspace/room IDs are valid
+
+### Debug Mode
+
+Enable debug mode for detailed logging:
+
+```bash
+uv run python -m lerobot_arena_ai_server.cli --debug
+```
+
+### System Requirements
+
+- **CPU**: Multi-core recommended for 30Hz control
+- **Memory**: 8GB+ RAM recommended
+- **GPU**: CUDA-compatible GPU for fast inference (optional but recommended)
+- **Network**: Stable connection to Arena server
+
+## 📚 Architecture
+
+### Integrated Mode (Recommended)
+```
+┌─────────────────────────────────────┐    ┌─────────────────┐
+│        Single Application           │    │  LeRobot Arena  │
+│  ┌─────────────┐  ┌─────────────┐   │◄──►│   (Port 8000)   │
+│  │ Gradio UI   │  │ AI Server   │   │    └─────────────────┘
+│  │    (/)      │  │  (/api/*)   │   │             │
+│  └─────────────┘  └─────────────┘   │             │
+│       (Port 7860)                   │        Robot/Cameras
+└─────────────────────────────────────┘
+           │
+      Web Browser
+```
+
+### Development Mode
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Gradio UI     │    │   AI Server     │    │  LeRobot Arena  │
+│   (Port 7860)   │◄──►│   (Port 8001)   │◄──►│   (Port 8000)   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+    Web Browser              ACT Model              Robot/Cameras
+                             Inference
+```
+
+### Data Flow
+
+1. **Camera Data**: Robot cameras → Arena → AI Server
+2. **Joint State**: Robot joints → Arena → AI Server  
+3. **AI Inference**: Images + Joint State → ACT Model → Actions
+4. **Control Commands**: Actions → Arena → Robot
+
+### Session Lifecycle
+
+1. **Create**: Set up rooms in Arena, load ACT model
+2. **Start**: Begin inference loop (3Hz) and control loop (30Hz)
+3. **Running**: Process camera/joint data, generate actions
+4. **Stop**: Pause inference, maintain connections
+5. **Delete**: Clean up resources, disconnect from Arena
+
+## 🤝 Contributing
+
+1. Follow the existing code style
+2. Add tests for new features
+3. Update documentation
+4. Submit pull requests
+
+## 📄 License
+
+This project follows the same license as the parent LeRobot Arena project.
+
+---
+
+For more information, see the [LeRobot Arena documentation](../../README.md).

README_INTEGRATION.md

@@ -0,0 +1,138 @@
+# 🤖 Integrated Inference Server
+
+This is an integrated ACT Model Inference Server that combines **FastAPI** and **Gradio** on a single port, perfect for deployment and development.
+
+## 🚀 Quick Start
+
+```bash
+# Install dependencies
+uv sync
+
+# Run the integrated server
+uv run python launch_simple.py --host 0.0.0.0 --port 7860
+```
+
+## 📡 Access Points
+
+Once running, you can access:
+
+- **🎨 Gradio UI**: http://localhost:7860/
+- **📖 API Documentation**: http://localhost:7860/api/docs  
+- **🔄 Health Check**: http://localhost:7860/api/health
+- **📋 OpenAPI Schema**: http://localhost:7860/api/openapi.json
+
+## 🏗️ Architecture
+
+### Integration Approach
+- **Single Process**: Everything runs in one Python process
+- **Single Port**: Both API and UI on the same port (7860)
+- **FastAPI at `/api`**: Full REST API with automatic documentation
+- **Gradio at `/`**: User-friendly web interface
+- **Direct Session Management**: UI communicates directly with session manager (no HTTP overhead)
+
+### Key Components
+
+1. **`simple_integrated.py`**: Main integration logic
+   - Creates FastAPI app and mounts it at `/api`
+   - Creates Gradio interface and mounts it at `/`
+   - Provides `SimpleServerManager` for direct session access
+
+2. **`launch_simple.py`**: Entry point script
+   - Handles command-line arguments
+   - Starts the integrated application
+
+3. **`main.py`**: Core FastAPI application
+   - Session management endpoints
+   - Policy loading and inference
+   - OpenAPI documentation
+
+## 🔧 Features
+
+### For UI Users
+- ✅ **Simple Interface**: Create and manage AI sessions through web UI
+- ✅ **Real-time Status**: Live session monitoring and control
+- ✅ **Direct Performance**: No HTTP overhead for UI operations
+
+### For API Users  
+- ✅ **Full REST API**: Complete programmatic access
+- ✅ **Interactive Docs**: Automatic Swagger/OpenAPI documentation
+- ✅ **Standard Endpoints**: `/sessions`, `/health`, etc.
+- ✅ **CORS Enabled**: Ready for frontend integration
+
+### For Deployment
+- ✅ **Single Port**: Easy to deploy behind reverse proxy
+- ✅ **Docker Ready**: Dockerfile included
+- ✅ **Health Checks**: Built-in monitoring endpoints
+- ✅ **HuggingFace Spaces**: Perfect for cloud deployment
+
+## 📋 API Usage Examples
+
+### Health Check
+```bash
+curl http://localhost:7860/api/health
+```
+
+### Create Session
+```bash
+curl -X POST http://localhost:7860/api/sessions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "session_id": "my-robot",
+    "policy_path": "./checkpoints/act_so101_beyond",
+    "camera_names": ["front"],
+    "arena_server_url": "http://localhost:8000"
+  }'
+```
+
+### Start Inference
+```bash
+curl -X POST http://localhost:7860/api/sessions/my-robot/start
+```
+
+### Get Session Status
+```bash
+curl http://localhost:7860/api/sessions/my-robot
+```
+
+## 🐳 Docker Usage
+
+```bash
+# Build
+docker build -t inference-server .
+
+# Run
+docker run -p 7860:7860 inference-server
+```
+
+## 🔍 Testing
+
+Run the integration test to verify everything works:
+
+```bash
+uv run python test_integration.py
+```
+
+## 💡 Development Tips
+
+### Use Both Interfaces
+- **Development**: Use Gradio UI for quick testing and setup
+- **Production**: Use REST API for automated systems
+- **Integration**: Both can run simultaneously
+
+### Session Management
+- UI uses direct session manager access (faster)
+- API uses HTTP endpoints (standard REST)
+- Both share the same underlying session data
+
+### Debugging
+- Check logs for startup issues
+- Use `/api/health` to verify API is working
+- Visit `/api/docs` for interactive API testing
+
+## 🚀 Benefits of This Approach
+
+1. **Flexibility**: Use UI or API as needed
+2. **Performance**: Direct access for UI, standard REST for API
+3. **Deployment**: Single port, single process
+4. **Documentation**: Auto-generated API docs
+5. **Development**: Fast iteration with integrated setup 

api-schema.yaml

@@ -0,0 +1,476 @@
+openapi: 3.1.0
+info:
+  title: LeRobot Arena AI Server
+  summary: ACT Model Inference Server for Real-time Robot Control
+  description: "\n        ## LeRobot Arena AI Server\n\n        This server provides\
+    \ **ACT (Action Chunking Transformer)** model inference for robotics applications.\n\
+    \        It uses the LeRobot Arena communication system with multiple rooms per\
+    \ session for:\n\n        ### Core Features:\n        - \U0001F3A5 **Multi-camera\
+    \ support**: Arbitrary number of camera streams with unique names\n        - \U0001F916\
+    \ **Joint control**: Normalized joint value handling (-100 to +100 range)\n  \
+    \      - \U0001F504 **Real-time inference**: Optimized for robotics control loops\n\
+    \        - \U0001F4CA **Session management**: Multiple concurrent inference sessions\n\
+    \        - \U0001F6E0️ **Debug endpoints**: Comprehensive monitoring and debugging\
+    \ tools\n\n        ### Communication Architecture:\n        1. **Camera rooms**:\
+    \ Receives video streams from robot cameras (supports multiple cameras)\n    \
+    \    2. **Joint input room**: Receives current robot joint positions (**NORMALIZED\
+    \ VALUES**)\n        3. **Joint output room**: Sends predicted joint commands\
+    \ (**NORMALIZED VALUES**)\n\n        ### Supported Cameras:\n        Each camera\
+    \ stream has a unique name (e.g., \"front\", \"wrist\", \"overhead\") \n     \
+    \   and all streams are synchronized for inference.\n\n        ### Joint Value\
+    \ Convention:\n        - All joint inputs/outputs use **NORMALIZED VALUES**\n\
+    \        - Range: -100 to +100 for most joints, 0 to 100 for gripper\n       \
+    \ - Matches training data format exactly\n\n        ### Getting Started:\n   \
+    \     1. Create a session with your trained ACT model\n        2. Connect your\
+    \ robot to the generated rooms\n        3. Start inference to begin real-time\
+    \ control\n        "
+  version: 1.0.0
+  contact:
+    name: LeRobot Arena Team
+    url: https://github.com/huggingface/lerobot
+  license:
+    name: Apache 2.0
+    url: https://www.apache.org/licenses/LICENSE-2.0.html
+  x-logo:
+    url: https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.png
+    altText: LeRobot Logo
+paths:
+  /:
+    get:
+      tags:
+      - Health
+      summary: Root
+      description: Health check endpoint.
+      operationId: root__get
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+  /health:
+    get:
+      tags:
+      - Health
+      summary: Health Check
+      description: Detailed health check.
+      operationId: health_check_health_get
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+  /sessions:
+    get:
+      tags:
+      - Sessions
+      summary: List Sessions
+      description: List all sessions.
+      operationId: list_sessions_sessions_get
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema:
+                items:
+                  $ref: '#/components/schemas/SessionStatusResponse'
+                type: array
+                title: Response List Sessions Sessions Get
+    post:
+      tags:
+      - Sessions
+      summary: Create Session
+      description: 'Create a new inference session.
+
+
+        If workspace_id is provided, all rooms will be created in that workspace.
+
+        If workspace_id is not provided, a new workspace will be generated automatically.
+
+        All rooms for a session (cameras + joints) are always created in the same
+        workspace.'
+      operationId: create_session_sessions_post
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/CreateSessionRequest'
+        required: true
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/CreateSessionResponse'
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+  /sessions/{session_id}:
+    get:
+      tags:
+      - Sessions
+      summary: Get Session Status
+      description: Get status of a specific session.
+      operationId: get_session_status_sessions__session_id__get
+      parameters:
+      - name: session_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Session Id
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/SessionStatusResponse'
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+    delete:
+      tags:
+      - Sessions
+      summary: Delete Session
+      description: Delete a session.
+      operationId: delete_session_sessions__session_id__delete
+      parameters:
+      - name: session_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Session Id
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+  /sessions/{session_id}/start:
+    post:
+      tags:
+      - Control
+      summary: Start Inference
+      description: Start inference for a session.
+      operationId: start_inference_sessions__session_id__start_post
+      parameters:
+      - name: session_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Session Id
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+  /sessions/{session_id}/stop:
+    post:
+      tags:
+      - Control
+      summary: Stop Inference
+      description: Stop inference for a session.
+      operationId: stop_inference_sessions__session_id__stop_post
+      parameters:
+      - name: session_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Session Id
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+  /sessions/{session_id}/restart:
+    post:
+      tags:
+      - Control
+      summary: Restart Inference
+      description: Restart inference for a session.
+      operationId: restart_inference_sessions__session_id__restart_post
+      parameters:
+      - name: session_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Session Id
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+  /debug/system:
+    get:
+      tags:
+      - Debug
+      summary: Get System Info
+      description: Get system information for debugging.
+      operationId: get_system_info_debug_system_get
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+  /debug/logs:
+    get:
+      tags:
+      - Debug
+      summary: Get Recent Logs
+      description: Get recent log entries for debugging.
+      operationId: get_recent_logs_debug_logs_get
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+  /debug/sessions/{session_id}/reset:
+    post:
+      tags:
+      - Debug
+      summary: Debug Reset Session
+      description: Reset a session's internal state for debugging.
+      operationId: debug_reset_session_debug_sessions__session_id__reset_post
+      parameters:
+      - name: session_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Session Id
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+  /debug/sessions/{session_id}/queue:
+    get:
+      tags:
+      - Debug
+      summary: Get Session Queue Info
+      description: Get detailed information about a session's action queue.
+      operationId: get_session_queue_info_debug_sessions__session_id__queue_get
+      parameters:
+      - name: session_id
+        in: path
+        required: true
+        schema:
+          type: string
+          title: Session Id
+      responses:
+        '200':
+          description: Successful Response
+          content:
+            application/json:
+              schema: {}
+        '422':
+          description: Validation Error
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/HTTPValidationError'
+components:
+  schemas:
+    CreateSessionRequest:
+      properties:
+        session_id:
+          type: string
+          title: Session Id
+        policy_path:
+          type: string
+          title: Policy Path
+        camera_names:
+          items:
+            type: string
+          type: array
+          title: Camera Names
+          default:
+          - front
+        arena_server_url:
+          type: string
+          title: Arena Server Url
+          default: http://localhost:8000
+        workspace_id:
+          anyOf:
+          - type: string
+          - type: 'null'
+          title: Workspace Id
+      type: object
+      required:
+      - session_id
+      - policy_path
+      title: CreateSessionRequest
+    CreateSessionResponse:
+      properties:
+        workspace_id:
+          type: string
+          title: Workspace Id
+        camera_room_ids:
+          additionalProperties:
+            type: string
+          type: object
+          title: Camera Room Ids
+        joint_input_room_id:
+          type: string
+          title: Joint Input Room Id
+        joint_output_room_id:
+          type: string
+          title: Joint Output Room Id
+      type: object
+      required:
+      - workspace_id
+      - camera_room_ids
+      - joint_input_room_id
+      - joint_output_room_id
+      title: CreateSessionResponse
+    HTTPValidationError:
+      properties:
+        detail:
+          items:
+            $ref: '#/components/schemas/ValidationError'
+          type: array
+          title: Detail
+      type: object
+      title: HTTPValidationError
+    SessionStatusResponse:
+      properties:
+        session_id:
+          type: string
+          title: Session Id
+        status:
+          type: string
+          title: Status
+        policy_path:
+          type: string
+          title: Policy Path
+        camera_names:
+          items:
+            type: string
+          type: array
+          title: Camera Names
+        workspace_id:
+          type: string
+          title: Workspace Id
+        rooms:
+          additionalProperties: true
+          type: object
+          title: Rooms
+        stats:
+          additionalProperties: true
+          type: object
+          title: Stats
+        inference_stats:
+          anyOf:
+          - additionalProperties: true
+            type: object
+          - type: 'null'
+          title: Inference Stats
+        error_message:
+          anyOf:
+          - type: string
+          - type: 'null'
+          title: Error Message
+      type: object
+      required:
+      - session_id
+      - status
+      - policy_path
+      - camera_names
+      - workspace_id
+      - rooms
+      - stats
+      title: SessionStatusResponse
+    ValidationError:
+      properties:
+        loc:
+          items:
+            anyOf:
+            - type: string
+            - type: integer
+          type: array
+          title: Location
+        msg:
+          type: string
+          title: Message
+        type:
+          type: string
+          title: Error Type
+      type: object
+      required:
+      - loc
+      - msg
+      - type
+      title: ValidationError
+  securitySchemes:
+    BearerAuth:
+      type: http
+      scheme: bearer
+      bearerFormat: JWT
+    ApiKeyAuth:
+      type: apiKey
+      in: header
+      name: X-API-Key
+servers:
+- url: http://localhost:8001
+  description: Development server
+- url: https://your-production-server.com
+  description: Production server
+tags:
+- name: Health
+  description: Health check and server status endpoints
+- name: Sessions
+  description: Inference session management - create, control, and monitor AI sessions
+- name: Control
+  description: Session control operations - start, stop, restart inference
+- name: Debug
+  description: Debug and monitoring endpoints for system diagnostics

client/.cursor/rules/use-bun-instead-of-node-vite-npm-pnpm.mdc

@@ -0,0 +1,98 @@
+---
+description: Use Bun instead of Node.js, npm, pnpm, or vite.
+globs: *.ts, *.tsx, *.html, *.css, *.js, *.jsx, package.json
+alwaysApply: false
+---
+
+Default to using Bun instead of Node.js.
+
+- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
+- Use `bun test` instead of `jest` or `vitest`
+- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
+- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
+- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
+- Bun automatically loads .env, so don't use dotenv.
+
+## APIs
+
+- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
+- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
+- `Bun.redis` for Redis. Don't use `ioredis`.
+- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
+- `WebSocket` is built-in. Don't use `ws`.
+- Bun.$`ls` instead of execa.
+
+## Frontend
+
+Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
+
+Server:
+
+```ts#index.ts
+import index from "./index.html"
+
+Bun.serve({
+  routes: {
+    "/": index,
+    "/api/users/:id": {
+      GET: (req) => {
+        return new Response(JSON.stringify({ id: req.params.id }));
+      },
+    },
+  },
+  // optional websocket support
+  websocket: {
+    open: (ws) => {
+      ws.send("Hello, world!");
+    },
+    message: (ws, message) => {
+      ws.send(message);
+    },
+    close: (ws) => {
+      // handle close
+    }
+  },
+  development: {
+    hmr: true,
+    console: true,
+  }
+})
+```
+
+HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
+
+```html#index.html
+<html>
+  <body>
+    <h1>Hello, world!</h1>
+    <script type="module" src="./frontend.tsx"></script>
+  </body>
+</html>
+```
+
+With the following `frontend.tsx`:
+
+```tsx#frontend.tsx
+import React from "react";
+
+// import .css files directly and it works
+import './index.css';
+
+import { createRoot } from "react-dom/client";
+
+const root = createRoot(document.body);
+
+export default function Frontend() {
+  return <h1>Hello, world!</h1>;
+}
+
+root.render(<Frontend />);
+```
+
+Then, run index.ts
+
+```sh
+bun --hot ./index.ts
+```
+
+For more information, read the Bun API docs in `node_modules/bun-types/docs/**.md`.

client/.gitignore

@@ -0,0 +1,34 @@
+# dependencies (bun install)
+node_modules
+
+# output
+out
+dist
+*.tgz
+
+# code coverage
+coverage
+*.lcov
+
+# logs
+logs
+_.log
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+
+# IntelliJ based IDEs
+.idea
+
+# Finder (MacOS) folder config
+.DS_Store

client/README.md

@@ -0,0 +1,205 @@
+# LeRobot Arena Inference Server TypeScript Client
+
+A TypeScript client for the LeRobot Arena Inference Server, providing ACT (Action Chunking Transformer) model inference and session management capabilities.
+
+## Features
+
+- ✅ **Fully Generated**: Client is 100% generated from OpenAPI spec
+- 🔒 **Type Safe**: Complete TypeScript support with generated types
+- 🚀 **Modern**: Built with Bun and modern JavaScript features
+- 📦 **Lightweight**: Minimal dependencies, uses fetch API
+- 🛠️ **Developer Friendly**: Comprehensive examples and documentation
+
+## Installation
+
+```bash
+# Install dependencies
+bun install
+
+# Generate client from OpenAPI spec
+bun run generate
+
+# Build the client
+bun run build
+```
+
+## Quick Start
+
+```typescript
+import { LeRobotInferenceServerClient, CreateSessionRequest } from '@lerobot-arena/inference-server-client';
+
+// Create client
+const client = new LeRobotInferenceServerClient('http://localhost:8001');
+
+// Check server health
+const isHealthy = await client.isHealthy();
+if (!isHealthy) {
+  console.error('Server is not available');
+  process.exit(1);
+}
+
+// Create and start a session
+const sessionRequest: CreateSessionRequest = {
+  session_id: 'my-robot-session',
+  policy_path: './checkpoints/act_so101_beyond',
+  camera_names: ['front', 'wrist'],
+  arena_server_url: 'http://localhost:8000'
+};
+
+const session = await client.createSession(sessionRequest);
+await client.startInference('my-robot-session');
+
+// Monitor session
+const status = await client.getSessionStatus('my-robot-session');
+console.log(`Status: ${status.status}`);
+
+// Clean up
+await client.deleteSession('my-robot-session');
+```
+
+## API Reference
+
+### Client Creation
+
+```typescript
+const client = new LeRobotInferenceServerClient(baseUrl: string);
+```
+
+### Health Check Methods
+
+- `isHealthy()`: Quick boolean health check
+- `getHealth()`: Detailed health information
+
+### Session Management
+
+- `createSession(request: CreateSessionRequest)`: Create inference session
+- `listSessions()`: List all active sessions
+- `getSessionStatus(sessionId: string)`: Get session details
+- `deleteSession(sessionId: string)`: Delete session and cleanup
+
+### Inference Control
+
+- `startInference(sessionId: string)`: Start model inference
+- `stopInference(sessionId: string)`: Stop model inference  
+- `restartInference(sessionId: string)`: Restart model inference
+
+### Utility Methods
+
+- `waitForSessionStatus(sessionId, targetStatus, timeout)`: Wait for status change
+- `createAndStartSession(request)`: Create session and start inference in one call
+
+### Debug Methods
+
+- `getSystemInfo()`: Get server system information
+- `debugResetSession(sessionId: string)`: Reset session state
+- `getSessionQueueInfo(sessionId: string)`: Get action queue details
+
+## Generated Types
+
+All types are generated from the OpenAPI specification:
+
+```typescript
+import type { 
+  CreateSessionRequest,
+  CreateSessionResponse,
+  SessionStatusResponse,
+  // ... all other types
+} from '@lerobot-arena/inference-server-client';
+```
+
+Key types:
+- `CreateSessionRequest`: Session creation parameters
+- `CreateSessionResponse`: Session creation result with room IDs
+- `SessionStatusResponse`: Complete session status and statistics
+
+## Examples
+
+### Basic Usage
+```bash
+bun run examples/basic-usage.ts
+```
+
+### Quick Example  
+```bash
+bun run examples/basic-usage.ts --quick
+```
+
+## Development
+
+### Scripts
+
+- `bun run generate`: Export OpenAPI schema and generate client
+- `bun run build`: Build the client distribution
+- `bun run typecheck`: Run TypeScript type checking
+- `bun run test`: Run tests
+- `bun run clean`: Clean generated files and dist
+
+### Regenerating Client
+
+The client is automatically regenerated when you run `bun run build`. To manually regenerate:
+
+```bash
+# Export latest OpenAPI schema from inference server
+bun run export-openapi
+
+# Generate TypeScript client from schema
+bun run generate-client
+```
+
+### File Structure
+
+```
+services/inference-server/client/
+├── src/
+│   ├── generated/          # Auto-generated from OpenAPI
+│   │   ├── index.ts        # Generated exports
+│   │   ├── services.gen.ts # Generated API methods
+│   │   ├── types.gen.ts    # Generated TypeScript types
+│   │   └── schemas.gen.ts  # Generated schemas
+│   └── index.ts            # Main client wrapper
+├── examples/
+│   └── basic-usage.ts      # Usage examples
+├── dist/                   # Built files
+├── openapi.json           # Latest OpenAPI schema
+└── package.json
+```
+
+## Requirements
+
+- **Bun** >= 1.0.0 (for development and building)
+- **LeRobot Arena Inference Server** running on target URL
+- **LeRobot Arena Transport Server** for communication rooms
+
+## Communication Architecture
+
+The inference server uses the LeRobot Arena communication system:
+
+1. **Camera Rooms**: Receive video streams (supports multiple cameras)
+2. **Joint Input Room**: Receives current robot joint positions (normalized -100 to +100)
+3. **Joint Output Room**: Sends predicted joint commands (normalized -100 to +100)
+
+All rooms are created in the same workspace for session isolation.
+
+## Error Handling
+
+All client methods throw descriptive errors on failure:
+
+```typescript
+try {
+  await client.createSession(request);
+} catch (error) {
+  console.error('Session creation failed:', error.message);
+}
+```
+
+## Contributing
+
+This client is auto-generated from the OpenAPI specification. To make changes:
+
+1. Update the inference server's FastAPI endpoints
+2. Regenerate the client: `bun run generate`
+3. Update examples and documentation as needed
+
+## License
+
+Apache 2.0 - See LICENSE file for details.

client/bun.lock

@@ -0,0 +1,128 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "client",
+      "dependencies": {
+        "@hey-api/client-fetch": "^0.2.4",
+      },
+      "devDependencies": {
+        "@hey-api/openapi-ts": "^0.53.12",
+        "@types/bun": "latest",
+        "typescript": "^5.8.3",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@apidevtools/json-schema-ref-parser": ["@apidevtools/json-schema-ref-parser@11.7.2", "", { "dependencies": { "@jsdevtools/ono": "^7.1.3", "@types/json-schema": "^7.0.15", "js-yaml": "^4.1.0" } }, "sha512-4gY54eEGEstClvEkGnwVkTkrx0sqwemEFG5OSRRn3tD91XH0+Q8XIkYIfo7IwEWPpJZwILb9GUXeShtplRc/eA=="],
+
+    "@hey-api/client-fetch": ["@hey-api/client-fetch@0.2.4", "", {}, "sha512-SGTVAVw3PlKDLw+IyhNhb/jCH3P1P2xJzLxA8Kyz1g95HrkYOJdRpl9F5I7LLwo9aCIB7nwR2NrSeX7QaQD7vQ=="],
+
+    "@hey-api/openapi-ts": ["@hey-api/openapi-ts@0.53.12", "", { "dependencies": { "@apidevtools/json-schema-ref-parser": "11.7.2", "c12": "2.0.1", "commander": "12.1.0", "handlebars": "4.7.8" }, "peerDependencies": { "typescript": "^5.x" }, "bin": { "openapi-ts": "bin/index.cjs" } }, "sha512-cOm8AlUqJIWdLXq+Pk4mTXhEApRSc9xEWTVT8MZAyEqrN1Yhiisl2wyZGH9quzKpolq+oqvgcx61txtwHwi8vQ=="],
+
+    "@jsdevtools/ono": ["@jsdevtools/ono@7.1.3", "", {}, "sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg=="],
+
+    "@types/bun": ["@types/bun@1.2.17", "", { "dependencies": { "bun-types": "1.2.17" } }, "sha512-l/BYs/JYt+cXA/0+wUhulYJB6a6p//GTPiJ7nV+QHa8iiId4HZmnu/3J/SowP5g0rTiERY2kfGKXEK5Ehltx4Q=="],
+
+    "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
+
+    "@types/node": ["@types/node@24.0.3", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-R4I/kzCYAdRLzfiCabn9hxWfbuHS573x+r0dJMkkzThEa7pbrcDWK+9zu3e7aBOouf+rQAciqPFMnxwr0aWgKg=="],
+
+    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
+    "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
+
+    "bun-types": ["bun-types@1.2.17", "", { "dependencies": { "@types/node": "*" } }, "sha512-ElC7ItwT3SCQwYZDYoAH+q6KT4Fxjl8DtZ6qDulUFBmXA8YB4xo+l54J9ZJN+k2pphfn9vk7kfubeSd5QfTVJQ=="],
+
+    "c12": ["c12@2.0.1", "", { "dependencies": { "chokidar": "^4.0.1", "confbox": "^0.1.7", "defu": "^6.1.4", "dotenv": "^16.4.5", "giget": "^1.2.3", "jiti": "^2.3.0", "mlly": "^1.7.1", "ohash": "^1.1.4", "pathe": "^1.1.2", "perfect-debounce": "^1.0.0", "pkg-types": "^1.2.0", "rc9": "^2.1.2" }, "peerDependencies": { "magicast": "^0.3.5" }, "optionalPeers": ["magicast"] }, "sha512-Z4JgsKXHG37C6PYUtIxCfLJZvo6FyhHJoClwwb9ftUkLpPSkuYqn6Tr+vnaN8hymm0kIbcg6Ey3kv/Q71k5w/A=="],
+
+    "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
+
+    "chownr": ["chownr@2.0.0", "", {}, "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ=="],
+
+    "citty": ["citty@0.1.6", "", { "dependencies": { "consola": "^3.2.3" } }, "sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ=="],
+
+    "commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="],
+
+    "confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
+
+    "consola": ["consola@3.4.2", "", {}, "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA=="],
+
+    "defu": ["defu@6.1.4", "", {}, "sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg=="],
+
+    "destr": ["destr@2.0.5", "", {}, "sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA=="],
+
+    "dotenv": ["dotenv@16.5.0", "", {}, "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg=="],
+
+    "fs-minipass": ["fs-minipass@2.1.0", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg=="],
+
+    "giget": ["giget@1.2.5", "", { "dependencies": { "citty": "^0.1.6", "consola": "^3.4.0", "defu": "^6.1.4", "node-fetch-native": "^1.6.6", "nypm": "^0.5.4", "pathe": "^2.0.3", "tar": "^6.2.1" }, "bin": { "giget": "dist/cli.mjs" } }, "sha512-r1ekGw/Bgpi3HLV3h1MRBIlSAdHoIMklpaQ3OQLFcRw9PwAj2rqigvIbg+dBUI51OxVI2jsEtDywDBjSiuf7Ug=="],
+
+    "handlebars": ["handlebars@4.7.8", "", { "dependencies": { "minimist": "^1.2.5", "neo-async": "^2.6.2", "source-map": "^0.6.1", "wordwrap": "^1.0.0" }, "optionalDependencies": { "uglify-js": "^3.1.4" }, "bin": { "handlebars": "bin/handlebars" } }, "sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ=="],
+
+    "jiti": ["jiti@2.4.2", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-rg9zJN+G4n2nfJl5MW3BMygZX56zKPNVEYYqq7adpmMh4Jn2QNEwhvQlFy6jPVdcod7txZtKHWnyZiA3a0zP7A=="],
+
+    "js-yaml": ["js-yaml@4.1.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="],
+
+    "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
+
+    "minipass": ["minipass@5.0.0", "", {}, "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ=="],
+
+    "minizlib": ["minizlib@2.1.2", "", { "dependencies": { "minipass": "^3.0.0", "yallist": "^4.0.0" } }, "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg=="],
+
+    "mkdirp": ["mkdirp@1.0.4", "", { "bin": { "mkdirp": "bin/cmd.js" } }, "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw=="],
+
+    "mlly": ["mlly@1.7.4", "", { "dependencies": { "acorn": "^8.14.0", "pathe": "^2.0.1", "pkg-types": "^1.3.0", "ufo": "^1.5.4" } }, "sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw=="],
+
+    "neo-async": ["neo-async@2.6.2", "", {}, "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="],
+
+    "node-fetch-native": ["node-fetch-native@1.6.6", "", {}, "sha512-8Mc2HhqPdlIfedsuZoc3yioPuzp6b+L5jRCRY1QzuWZh2EGJVQrGppC6V6cF0bLdbW0+O2YpqCA25aF/1lvipQ=="],
+
+    "nypm": ["nypm@0.5.4", "", { "dependencies": { "citty": "^0.1.6", "consola": "^3.4.0", "pathe": "^2.0.3", "pkg-types": "^1.3.1", "tinyexec": "^0.3.2", "ufo": "^1.5.4" }, "bin": { "nypm": "dist/cli.mjs" } }, "sha512-X0SNNrZiGU8/e/zAB7sCTtdxWTMSIO73q+xuKgglm2Yvzwlo8UoC5FNySQFCvl84uPaeADkqHUZUkWy4aH4xOA=="],
+
+    "ohash": ["ohash@1.1.6", "", {}, "sha512-TBu7PtV8YkAZn0tSxobKY2n2aAQva936lhRrj6957aDaCf9IEtqsKbgMzXE/F/sjqYOwmrukeORHNLe5glk7Cg=="],
+
+    "pathe": ["pathe@1.1.2", "", {}, "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ=="],
+
+    "perfect-debounce": ["perfect-debounce@1.0.0", "", {}, "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA=="],
+
+    "pkg-types": ["pkg-types@1.3.1", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="],
+
+    "rc9": ["rc9@2.1.2", "", { "dependencies": { "defu": "^6.1.4", "destr": "^2.0.3" } }, "sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg=="],
+
+    "readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
+
+    "source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
+
+    "tar": ["tar@6.2.1", "", { "dependencies": { "chownr": "^2.0.0", "fs-minipass": "^2.0.0", "minipass": "^5.0.0", "minizlib": "^2.1.1", "mkdirp": "^1.0.3", "yallist": "^4.0.0" } }, "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A=="],
+
+    "tinyexec": ["tinyexec@0.3.2", "", {}, "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA=="],
+
+    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
+
+    "ufo": ["ufo@1.6.1", "", {}, "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA=="],
+
+    "uglify-js": ["uglify-js@3.19.3", "", { "bin": { "uglifyjs": "bin/uglifyjs" } }, "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ=="],
+
+    "undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
+
+    "wordwrap": ["wordwrap@1.0.0", "", {}, "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q=="],
+
+    "yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
+
+    "fs-minipass/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "giget/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "minizlib/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "mlly/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "nypm/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "pkg-types/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+  }
+}

client/examples/basic-usage.ts

@@ -0,0 +1,149 @@
+#!/usr/bin/env bun
+/**
+ * Basic Usage Example for LeRobot Arena Inference Server TypeScript Client
+ * 
+ * This example demonstrates how to:
+ * 1. Create a client instance
+ * 2. Check server health
+ * 3. Create an inference session
+ * 4. Start inference
+ * 5. Monitor session status
+ * 6. Clean up resources
+ */
+
+import { 
+  LeRobotInferenceServerClient
+} from '../src/index';
+
+import type { 
+  CreateSessionRequest,
+  SessionStatusResponse 
+} from '../src/generated';
+
+async function main() {
+  // Create client instance
+  const client = new LeRobotInferenceServerClient('http://localhost:8001');
+
+  try {
+    console.log('🔍 Checking server health...');
+    const isHealthy = await client.isHealthy();
+    if (!isHealthy) {
+      console.error('❌ Server is not healthy. Make sure the inference server is running.');
+      process.exit(1);
+    }
+    console.log('✅ Server is healthy!');
+
+    // Get detailed health info
+    const healthInfo = await client.getHealth();
+    console.log('📊 Server status:', healthInfo);
+
+    // Create a session (using generated types)
+    const sessionRequest: CreateSessionRequest = {
+      session_id: 'example-session-' + Date.now(),
+      policy_path: './checkpoints/act_so101_beyond', // Update with your model path
+      camera_names: ['front', 'wrist'], // Update with your camera names
+      arena_server_url: 'http://localhost:8000', // Update with your arena server URL
+      workspace_id: null // Let the server generate a workspace ID
+    };
+
+    console.log('🚀 Creating inference session...');
+    const session = await client.createSession(sessionRequest);
+    console.log('✅ Session created!');
+    console.log('📍 Workspace ID:', session.workspace_id);
+    console.log('📷 Camera rooms:', session.camera_room_ids);
+    console.log('🔄 Joint input room:', session.joint_input_room_id);
+    console.log('🎯 Joint output room:', session.joint_output_room_id);
+
+    // Start inference
+    console.log('▶️ Starting inference...');
+    await client.startInference(sessionRequest.session_id);
+    console.log('✅ Inference started!');
+
+    // Wait for the session to be running
+    console.log('⏳ Waiting for session to be running...');
+    const runningStatus = await client.waitForSessionStatus(
+      sessionRequest.session_id, 
+      'running', 
+      30000 // 30 second timeout
+    );
+    console.log('🏃 Session is now running!');
+
+    // Monitor the session for a few seconds
+    console.log('📊 Monitoring session status...');
+    for (let i = 0; i < 5; i++) {
+      const status: SessionStatusResponse = await client.getSessionStatus(sessionRequest.session_id);
+      console.log(`📈 Status: ${status.status}, Stats:`, status.stats);
+      
+      // Wait 2 seconds before next check
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+
+    // Get system info for debugging
+    console.log('🔧 Getting system information...');
+    const systemInfo = await client.getSystemInfo();
+    console.log('💻 System info:', systemInfo);
+
+    // Get session queue info
+    console.log('📋 Getting session queue info...');
+    const queueInfo = await client.getSessionQueueInfo(sessionRequest.session_id);
+    console.log('📝 Queue info:', queueInfo);
+
+    // Stop inference
+    console.log('⏹️ Stopping inference...');
+    await client.stopInference(sessionRequest.session_id);
+    console.log('✅ Inference stopped!');
+
+    // Clean up - delete the session
+    console.log('🧹 Cleaning up session...');
+    await client.deleteSession(sessionRequest.session_id);
+    console.log('✅ Session deleted!');
+
+    console.log('🎉 Example completed successfully!');
+
+  } catch (error) {
+    console.error('❌ Error:', error);
+    process.exit(1);
+  }
+}
+
+// Alternative: Using the convenience function
+async function quickExample() {
+  const client = new LeRobotInferenceServerClient('http://localhost:8001');
+
+  try {
+    // This creates a session and starts inference in one call
+    const result = await client.createAndStartSession({
+      session_id: 'quick-example-' + Date.now(),
+      policy_path: './checkpoints/act_so101_beyond',
+      camera_names: ['front'],
+      arena_server_url: 'http://localhost:8000'
+    });
+
+    console.log('🚀 Quick session created and started!');
+    console.log('Session:', result.session);
+    console.log('Status:', result.status);
+
+    // Clean up
+    await client.deleteSession(result.status.session_id);
+    console.log('✅ Quick example completed!');
+
+  } catch (error) {
+    console.error('❌ Quick example error:', error);
+  }
+}
+
+// Run the main example
+if (import.meta.main) {
+  console.log('=== LeRobot Arena Inference Server Client Example ===\n');
+  
+  // Choose which example to run based on command line argument
+  const runQuick = process.argv.includes('--quick');
+  
+  if (runQuick) {
+    console.log('Running quick example...\n');
+    await quickExample();
+  } else {
+    console.log('Running full example...\n');
+    await main();
+  }
+} 

client/openapi.json

@@ -0,0 +1,710 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "Inference Server",
+    "summary": "ACT Model Inference Server for Real-time Robot Control",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/": {
+      "get": {
+        "tags": [
+          "Health"
+        ],
+        "summary": "Root",
+        "description": "Health check endpoint.",
+        "operationId": "root__get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/health": {
+      "get": {
+        "tags": [
+          "Health"
+        ],
+        "summary": "Health Check",
+        "description": "Detailed health check.",
+        "operationId": "health_check_health_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/policies": {
+      "get": {
+        "tags": [
+          "Policies"
+        ],
+        "summary": "List Policies",
+        "description": "List supported policy types.",
+        "operationId": "list_policies_policies_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions": {
+      "get": {
+        "tags": [
+          "Sessions"
+        ],
+        "summary": "List Sessions",
+        "description": "List all sessions.",
+        "operationId": "list_sessions_sessions_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "items": {
+                    "$ref": "#/components/schemas/SessionStatusResponse"
+                  },
+                  "type": "array",
+                  "title": "Response List Sessions Sessions Get"
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "Sessions"
+        ],
+        "summary": "Create Session",
+        "description": "Create a new inference session.\n\nIf workspace_id is provided, all rooms will be created in that workspace.\nIf workspace_id is not provided, a new workspace will be generated automatically.\nAll rooms for a session (cameras + joints) are always created in the same workspace.",
+        "operationId": "create_session_sessions_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateSessionRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CreateSessionResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions/{session_id}": {
+      "get": {
+        "tags": [
+          "Sessions"
+        ],
+        "summary": "Get Session Status",
+        "description": "Get status of a specific session.",
+        "operationId": "get_session_status_sessions__session_id__get",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SessionStatusResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "Sessions"
+        ],
+        "summary": "Delete Session",
+        "description": "Delete a session.",
+        "operationId": "delete_session_sessions__session_id__delete",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions/{session_id}/start": {
+      "post": {
+        "tags": [
+          "Control"
+        ],
+        "summary": "Start Inference",
+        "description": "Start inference for a session.",
+        "operationId": "start_inference_sessions__session_id__start_post",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions/{session_id}/stop": {
+      "post": {
+        "tags": [
+          "Control"
+        ],
+        "summary": "Stop Inference",
+        "description": "Stop inference for a session.",
+        "operationId": "stop_inference_sessions__session_id__stop_post",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions/{session_id}/restart": {
+      "post": {
+        "tags": [
+          "Control"
+        ],
+        "summary": "Restart Inference",
+        "description": "Restart inference for a session.",
+        "operationId": "restart_inference_sessions__session_id__restart_post",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/debug/system": {
+      "get": {
+        "tags": [
+          "Debug"
+        ],
+        "summary": "Get System Info",
+        "description": "Get system information for debugging.",
+        "operationId": "get_system_info_debug_system_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/debug/logs": {
+      "get": {
+        "tags": [
+          "Debug"
+        ],
+        "summary": "Get Recent Logs",
+        "description": "Get recent log entries for debugging.",
+        "operationId": "get_recent_logs_debug_logs_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/debug/sessions/{session_id}/reset": {
+      "post": {
+        "tags": [
+          "Debug"
+        ],
+        "summary": "Debug Reset Session",
+        "description": "Reset a session's internal state for debugging.",
+        "operationId": "debug_reset_session_debug_sessions__session_id__reset_post",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/debug/sessions/{session_id}/queue": {
+      "get": {
+        "tags": [
+          "Debug"
+        ],
+        "summary": "Get Session Queue Info",
+        "description": "Get detailed information about a session's action queue.",
+        "operationId": "get_session_queue_info_debug_sessions__session_id__queue_get",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "CreateSessionRequest": {
+        "properties": {
+          "session_id": {
+            "type": "string",
+            "title": "Session Id"
+          },
+          "policy_path": {
+            "type": "string",
+            "title": "Policy Path"
+          },
+          "camera_names": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array",
+            "title": "Camera Names",
+            "default": [
+              "front"
+            ]
+          },
+          "arena_server_url": {
+            "type": "string",
+            "title": "Arena Server Url",
+            "default": "http://localhost:8000"
+          },
+          "workspace_id": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Workspace Id"
+          },
+          "policy_type": {
+            "type": "string",
+            "title": "Policy Type",
+            "default": "act"
+          },
+          "language_instruction": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Language Instruction"
+          }
+        },
+        "type": "object",
+        "required": [
+          "session_id",
+          "policy_path"
+        ],
+        "title": "CreateSessionRequest"
+      },
+      "CreateSessionResponse": {
+        "properties": {
+          "workspace_id": {
+            "type": "string",
+            "title": "Workspace Id"
+          },
+          "camera_room_ids": {
+            "additionalProperties": {
+              "type": "string"
+            },
+            "type": "object",
+            "title": "Camera Room Ids"
+          },
+          "joint_input_room_id": {
+            "type": "string",
+            "title": "Joint Input Room Id"
+          },
+          "joint_output_room_id": {
+            "type": "string",
+            "title": "Joint Output Room Id"
+          }
+        },
+        "type": "object",
+        "required": [
+          "workspace_id",
+          "camera_room_ids",
+          "joint_input_room_id",
+          "joint_output_room_id"
+        ],
+        "title": "CreateSessionResponse"
+      },
+      "HTTPValidationError": {
+        "properties": {
+          "detail": {
+            "items": {
+              "$ref": "#/components/schemas/ValidationError"
+            },
+            "type": "array",
+            "title": "Detail"
+          }
+        },
+        "type": "object",
+        "title": "HTTPValidationError"
+      },
+      "SessionStatusResponse": {
+        "properties": {
+          "session_id": {
+            "type": "string",
+            "title": "Session Id"
+          },
+          "status": {
+            "type": "string",
+            "title": "Status"
+          },
+          "policy_path": {
+            "type": "string",
+            "title": "Policy Path"
+          },
+          "policy_type": {
+            "type": "string",
+            "title": "Policy Type"
+          },
+          "camera_names": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array",
+            "title": "Camera Names"
+          },
+          "workspace_id": {
+            "type": "string",
+            "title": "Workspace Id"
+          },
+          "rooms": {
+            "additionalProperties": true,
+            "type": "object",
+            "title": "Rooms"
+          },
+          "stats": {
+            "additionalProperties": true,
+            "type": "object",
+            "title": "Stats"
+          },
+          "inference_stats": {
+            "anyOf": [
+              {
+                "additionalProperties": true,
+                "type": "object"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Inference Stats"
+          },
+          "error_message": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Error Message"
+          }
+        },
+        "type": "object",
+        "required": [
+          "session_id",
+          "status",
+          "policy_path",
+          "policy_type",
+          "camera_names",
+          "workspace_id",
+          "rooms",
+          "stats"
+        ],
+        "title": "SessionStatusResponse"
+      },
+      "ValidationError": {
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          }
+        },
+        "type": "object",
+        "required": [
+          "loc",
+          "msg",
+          "type"
+        ],
+        "title": "ValidationError"
+      }
+    },
+    "securitySchemes": {
+      "BearerAuth": {
+        "type": "http",
+        "scheme": "bearer",
+        "bearerFormat": "JWT"
+      },
+      "ApiKeyAuth": {
+        "type": "apiKey",
+        "in": "header",
+        "name": "X-API-Key"
+      }
+    }
+  },
+  "tags": [
+    {
+      "name": "Health",
+      "description": "Health check and server status endpoints"
+    },
+    {
+      "name": "Sessions",
+      "description": "Inference session management - create, control, and monitor AI sessions"
+    },
+    {
+      "name": "Control",
+      "description": "Session control operations - start, stop, restart inference"
+    },
+    {
+      "name": "Debug",
+      "description": "Debug and monitoring endpoints for system diagnostics"
+    }
+  ]
+}

client/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@robohub/inference-server-client",
+  "version": "1.0.0",
+  "description": "TypeScript client for LeRobot Arena Inference Server - ACT model inference and session management",
+  "module": "dist/index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "private": true,
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --format esm --sourcemap && bunx tsc --emitDeclarationOnly --declaration --outDir ./dist/temp && cp -r ./dist/temp/src/* ./dist/ && rm -rf ./dist/temp",
+    "dev": "bun --watch src/index.ts",
+    "test": "bun test",
+    "typecheck": "bunx tsc --noEmit",
+    "clean": "rm -rf dist src/generated",
+    "export-openapi": "cd .. && uv run python -m inference_server.export_openapi --output client/openapi.json",
+    "generate-client": "bunx @hey-api/openapi-ts -i openapi.json -o src/generated -c @hey-api/client-fetch",
+    "generate": "bun run export-openapi && bun run generate-client",
+    "prebuild": "bun run clean && bun run generate"
+  },
+  "keywords": [
+    "lerobot",
+    "arena",
+    "inference-server",
+    "act",
+    "robotics",
+    "inference",
+    "typescript",
+    "client"
+  ],
+  "author": "Julien Blanchon",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@hey-api/client-fetch": "^0.2.4"
+  },
+  "devDependencies": {
+    "@hey-api/openapi-ts": "^0.53.12",
+    "@types/bun": "latest",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/julien-blanchon/RoboHub.git#main:services/inference-server/client",
+    "directory": "services/inference-server/client"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

client/src/generated/index.ts

@@ -0,0 +1,4 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export * from './schemas.gen';
+export * from './services.gen';
+export * from './types.gen';

client/src/generated/schemas.gen.ts

@@ -0,0 +1,196 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export const CreateSessionRequestSchema = {
+    properties: {
+        session_id: {
+            type: 'string',
+            title: 'Session Id'
+        },
+        policy_path: {
+            type: 'string',
+            title: 'Policy Path'
+        },
+        camera_names: {
+            items: {
+                type: 'string'
+            },
+            type: 'array',
+            title: 'Camera Names',
+            default: ['front']
+        },
+        arena_server_url: {
+            type: 'string',
+            title: 'Arena Server Url',
+            default: 'http://localhost:8000'
+        },
+        workspace_id: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'null'
+                }
+            ],
+            title: 'Workspace Id'
+        },
+        policy_type: {
+            type: 'string',
+            title: 'Policy Type',
+            default: 'act'
+        },
+        language_instruction: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'null'
+                }
+            ],
+            title: 'Language Instruction'
+        }
+    },
+    type: 'object',
+    required: ['session_id', 'policy_path'],
+    title: 'CreateSessionRequest'
+} as const;
+
+export const CreateSessionResponseSchema = {
+    properties: {
+        workspace_id: {
+            type: 'string',
+            title: 'Workspace Id'
+        },
+        camera_room_ids: {
+            additionalProperties: {
+                type: 'string'
+            },
+            type: 'object',
+            title: 'Camera Room Ids'
+        },
+        joint_input_room_id: {
+            type: 'string',
+            title: 'Joint Input Room Id'
+        },
+        joint_output_room_id: {
+            type: 'string',
+            title: 'Joint Output Room Id'
+        }
+    },
+    type: 'object',
+    required: ['workspace_id', 'camera_room_ids', 'joint_input_room_id', 'joint_output_room_id'],
+    title: 'CreateSessionResponse'
+} as const;
+
+export const HTTPValidationErrorSchema = {
+    properties: {
+        detail: {
+            items: {
+                '$ref': '#/components/schemas/ValidationError'
+            },
+            type: 'array',
+            title: 'Detail'
+        }
+    },
+    type: 'object',
+    title: 'HTTPValidationError'
+} as const;
+
+export const SessionStatusResponseSchema = {
+    properties: {
+        session_id: {
+            type: 'string',
+            title: 'Session Id'
+        },
+        status: {
+            type: 'string',
+            title: 'Status'
+        },
+        policy_path: {
+            type: 'string',
+            title: 'Policy Path'
+        },
+        policy_type: {
+            type: 'string',
+            title: 'Policy Type'
+        },
+        camera_names: {
+            items: {
+                type: 'string'
+            },
+            type: 'array',
+            title: 'Camera Names'
+        },
+        workspace_id: {
+            type: 'string',
+            title: 'Workspace Id'
+        },
+        rooms: {
+            additionalProperties: true,
+            type: 'object',
+            title: 'Rooms'
+        },
+        stats: {
+            additionalProperties: true,
+            type: 'object',
+            title: 'Stats'
+        },
+        inference_stats: {
+            anyOf: [
+                {
+                    additionalProperties: true,
+                    type: 'object'
+                },
+                {
+                    type: 'null'
+                }
+            ],
+            title: 'Inference Stats'
+        },
+        error_message: {
+            anyOf: [
+                {
+                    type: 'string'
+                },
+                {
+                    type: 'null'
+                }
+            ],
+            title: 'Error Message'
+        }
+    },
+    type: 'object',
+    required: ['session_id', 'status', 'policy_path', 'policy_type', 'camera_names', 'workspace_id', 'rooms', 'stats'],
+    title: 'SessionStatusResponse'
+} as const;
+
+export const ValidationErrorSchema = {
+    properties: {
+        loc: {
+            items: {
+                anyOf: [
+                    {
+                        type: 'string'
+                    },
+                    {
+                        type: 'integer'
+                    }
+                ]
+            },
+            type: 'array',
+            title: 'Location'
+        },
+        msg: {
+            type: 'string',
+            title: 'Message'
+        },
+        type: {
+            type: 'string',
+            title: 'Error Type'
+        }
+    },
+    type: 'object',
+    required: ['loc', 'msg', 'type'],
+    title: 'ValidationError'
+} as const;

client/src/generated/services.gen.ts

@@ -0,0 +1,164 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createClient, createConfig, type Options } from '@hey-api/client-fetch';
+import type { RootGetError, RootGetResponse, HealthCheckHealthGetError, HealthCheckHealthGetResponse, ListPoliciesPoliciesGetError, ListPoliciesPoliciesGetResponse, ListSessionsSessionsGetError, ListSessionsSessionsGetResponse, CreateSessionSessionsPostData, CreateSessionSessionsPostError, CreateSessionSessionsPostResponse, GetSessionStatusSessionsSessionIdGetData, GetSessionStatusSessionsSessionIdGetError, GetSessionStatusSessionsSessionIdGetResponse, DeleteSessionSessionsSessionIdDeleteData, DeleteSessionSessionsSessionIdDeleteError, DeleteSessionSessionsSessionIdDeleteResponse, StartInferenceSessionsSessionIdStartPostData, StartInferenceSessionsSessionIdStartPostError, StartInferenceSessionsSessionIdStartPostResponse, StopInferenceSessionsSessionIdStopPostData, StopInferenceSessionsSessionIdStopPostError, StopInferenceSessionsSessionIdStopPostResponse, RestartInferenceSessionsSessionIdRestartPostData, RestartInferenceSessionsSessionIdRestartPostError, RestartInferenceSessionsSessionIdRestartPostResponse, GetSystemInfoDebugSystemGetError, GetSystemInfoDebugSystemGetResponse, GetRecentLogsDebugLogsGetError, GetRecentLogsDebugLogsGetResponse, DebugResetSessionDebugSessionsSessionIdResetPostData, DebugResetSessionDebugSessionsSessionIdResetPostError, DebugResetSessionDebugSessionsSessionIdResetPostResponse, GetSessionQueueInfoDebugSessionsSessionIdQueueGetData, GetSessionQueueInfoDebugSessionsSessionIdQueueGetError, GetSessionQueueInfoDebugSessionsSessionIdQueueGetResponse } from './types.gen';
+
+export const client = createClient(createConfig());
+
+/**
+ * Root
+ * Health check endpoint.
+ */
+export const rootGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<RootGetResponse, RootGetError, ThrowOnError>({
+        ...options,
+        url: '/'
+    });
+};
+
+/**
+ * Health Check
+ * Detailed health check.
+ */
+export const healthCheckHealthGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<HealthCheckHealthGetResponse, HealthCheckHealthGetError, ThrowOnError>({
+        ...options,
+        url: '/health'
+    });
+};
+
+/**
+ * List Policies
+ * List supported policy types.
+ */
+export const listPoliciesPoliciesGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<ListPoliciesPoliciesGetResponse, ListPoliciesPoliciesGetError, ThrowOnError>({
+        ...options,
+        url: '/policies'
+    });
+};
+
+/**
+ * List Sessions
+ * List all sessions.
+ */
+export const listSessionsSessionsGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<ListSessionsSessionsGetResponse, ListSessionsSessionsGetError, ThrowOnError>({
+        ...options,
+        url: '/sessions'
+    });
+};
+
+/**
+ * Create Session
+ * Create a new inference session.
+ *
+ * If workspace_id is provided, all rooms will be created in that workspace.
+ * If workspace_id is not provided, a new workspace will be generated automatically.
+ * All rooms for a session (cameras + joints) are always created in the same workspace.
+ */
+export const createSessionSessionsPost = <ThrowOnError extends boolean = false>(options: Options<CreateSessionSessionsPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<CreateSessionSessionsPostResponse, CreateSessionSessionsPostError, ThrowOnError>({
+        ...options,
+        url: '/sessions'
+    });
+};
+
+/**
+ * Get Session Status
+ * Get status of a specific session.
+ */
+export const getSessionStatusSessionsSessionIdGet = <ThrowOnError extends boolean = false>(options: Options<GetSessionStatusSessionsSessionIdGetData, ThrowOnError>) => {
+    return (options?.client ?? client).get<GetSessionStatusSessionsSessionIdGetResponse, GetSessionStatusSessionsSessionIdGetError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}'
+    });
+};
+
+/**
+ * Delete Session
+ * Delete a session.
+ */
+export const deleteSessionSessionsSessionIdDelete = <ThrowOnError extends boolean = false>(options: Options<DeleteSessionSessionsSessionIdDeleteData, ThrowOnError>) => {
+    return (options?.client ?? client).delete<DeleteSessionSessionsSessionIdDeleteResponse, DeleteSessionSessionsSessionIdDeleteError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}'
+    });
+};
+
+/**
+ * Start Inference
+ * Start inference for a session.
+ */
+export const startInferenceSessionsSessionIdStartPost = <ThrowOnError extends boolean = false>(options: Options<StartInferenceSessionsSessionIdStartPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<StartInferenceSessionsSessionIdStartPostResponse, StartInferenceSessionsSessionIdStartPostError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}/start'
+    });
+};
+
+/**
+ * Stop Inference
+ * Stop inference for a session.
+ */
+export const stopInferenceSessionsSessionIdStopPost = <ThrowOnError extends boolean = false>(options: Options<StopInferenceSessionsSessionIdStopPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<StopInferenceSessionsSessionIdStopPostResponse, StopInferenceSessionsSessionIdStopPostError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}/stop'
+    });
+};
+
+/**
+ * Restart Inference
+ * Restart inference for a session.
+ */
+export const restartInferenceSessionsSessionIdRestartPost = <ThrowOnError extends boolean = false>(options: Options<RestartInferenceSessionsSessionIdRestartPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<RestartInferenceSessionsSessionIdRestartPostResponse, RestartInferenceSessionsSessionIdRestartPostError, ThrowOnError>({
+        ...options,
+        url: '/sessions/{session_id}/restart'
+    });
+};
+
+/**
+ * Get System Info
+ * Get system information for debugging.
+ */
+export const getSystemInfoDebugSystemGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<GetSystemInfoDebugSystemGetResponse, GetSystemInfoDebugSystemGetError, ThrowOnError>({
+        ...options,
+        url: '/debug/system'
+    });
+};
+
+/**
+ * Get Recent Logs
+ * Get recent log entries for debugging.
+ */
+export const getRecentLogsDebugLogsGet = <ThrowOnError extends boolean = false>(options?: Options<unknown, ThrowOnError>) => {
+    return (options?.client ?? client).get<GetRecentLogsDebugLogsGetResponse, GetRecentLogsDebugLogsGetError, ThrowOnError>({
+        ...options,
+        url: '/debug/logs'
+    });
+};
+
+/**
+ * Debug Reset Session
+ * Reset a session's internal state for debugging.
+ */
+export const debugResetSessionDebugSessionsSessionIdResetPost = <ThrowOnError extends boolean = false>(options: Options<DebugResetSessionDebugSessionsSessionIdResetPostData, ThrowOnError>) => {
+    return (options?.client ?? client).post<DebugResetSessionDebugSessionsSessionIdResetPostResponse, DebugResetSessionDebugSessionsSessionIdResetPostError, ThrowOnError>({
+        ...options,
+        url: '/debug/sessions/{session_id}/reset'
+    });
+};
+
+/**
+ * Get Session Queue Info
+ * Get detailed information about a session's action queue.
+ */
+export const getSessionQueueInfoDebugSessionsSessionIdQueueGet = <ThrowOnError extends boolean = false>(options: Options<GetSessionQueueInfoDebugSessionsSessionIdQueueGetData, ThrowOnError>) => {
+    return (options?.client ?? client).get<GetSessionQueueInfoDebugSessionsSessionIdQueueGetResponse, GetSessionQueueInfoDebugSessionsSessionIdQueueGetError, ThrowOnError>({
+        ...options,
+        url: '/debug/sessions/{session_id}/queue'
+    });
+};

client/src/generated/types.gen.ts

@@ -0,0 +1,151 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type CreateSessionRequest = {
+    session_id: string;
+    policy_path: string;
+    camera_names?: Array<(string)>;
+    arena_server_url?: string;
+    workspace_id?: (string | null);
+    policy_type?: string;
+    language_instruction?: (string | null);
+};
+
+export type CreateSessionResponse = {
+    workspace_id: string;
+    camera_room_ids: {
+        [key: string]: (string);
+    };
+    joint_input_room_id: string;
+    joint_output_room_id: string;
+};
+
+export type HTTPValidationError = {
+    detail?: Array<ValidationError>;
+};
+
+export type SessionStatusResponse = {
+    session_id: string;
+    status: string;
+    policy_path: string;
+    policy_type: string;
+    camera_names: Array<(string)>;
+    workspace_id: string;
+    rooms: {
+        [key: string]: unknown;
+    };
+    stats: {
+        [key: string]: unknown;
+    };
+    inference_stats?: ({
+    [key: string]: unknown;
+} | null);
+    error_message?: (string | null);
+};
+
+export type ValidationError = {
+    loc: Array<(string | number)>;
+    msg: string;
+    type: string;
+};
+
+export type RootGetResponse = (unknown);
+
+export type RootGetError = unknown;
+
+export type HealthCheckHealthGetResponse = (unknown);
+
+export type HealthCheckHealthGetError = unknown;
+
+export type ListPoliciesPoliciesGetResponse = (unknown);
+
+export type ListPoliciesPoliciesGetError = unknown;
+
+export type ListSessionsSessionsGetResponse = (Array<SessionStatusResponse>);
+
+export type ListSessionsSessionsGetError = unknown;
+
+export type CreateSessionSessionsPostData = {
+    body: CreateSessionRequest;
+};
+
+export type CreateSessionSessionsPostResponse = (CreateSessionResponse);
+
+export type CreateSessionSessionsPostError = (HTTPValidationError);
+
+export type GetSessionStatusSessionsSessionIdGetData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type GetSessionStatusSessionsSessionIdGetResponse = (SessionStatusResponse);
+
+export type GetSessionStatusSessionsSessionIdGetError = (HTTPValidationError);
+
+export type DeleteSessionSessionsSessionIdDeleteData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type DeleteSessionSessionsSessionIdDeleteResponse = (unknown);
+
+export type DeleteSessionSessionsSessionIdDeleteError = (HTTPValidationError);
+
+export type StartInferenceSessionsSessionIdStartPostData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type StartInferenceSessionsSessionIdStartPostResponse = (unknown);
+
+export type StartInferenceSessionsSessionIdStartPostError = (HTTPValidationError);
+
+export type StopInferenceSessionsSessionIdStopPostData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type StopInferenceSessionsSessionIdStopPostResponse = (unknown);
+
+export type StopInferenceSessionsSessionIdStopPostError = (HTTPValidationError);
+
+export type RestartInferenceSessionsSessionIdRestartPostData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type RestartInferenceSessionsSessionIdRestartPostResponse = (unknown);
+
+export type RestartInferenceSessionsSessionIdRestartPostError = (HTTPValidationError);
+
+export type GetSystemInfoDebugSystemGetResponse = (unknown);
+
+export type GetSystemInfoDebugSystemGetError = unknown;
+
+export type GetRecentLogsDebugLogsGetResponse = (unknown);
+
+export type GetRecentLogsDebugLogsGetError = unknown;
+
+export type DebugResetSessionDebugSessionsSessionIdResetPostData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type DebugResetSessionDebugSessionsSessionIdResetPostResponse = (unknown);
+
+export type DebugResetSessionDebugSessionsSessionIdResetPostError = (HTTPValidationError);
+
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetData = {
+    path: {
+        session_id: string;
+    };
+};
+
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetResponse = (unknown);
+
+export type GetSessionQueueInfoDebugSessionsSessionIdQueueGetError = (HTTPValidationError);

client/src/index.ts

@@ -0,0 +1,270 @@
+/**
+ * LeRobot Arena Inference Server TypeScript Client
+ * 
+ * This client provides TypeScript access to the LeRobot Arena Inference Server
+ * for ACT (Action Chunking Transformer) model inference and session management.
+ * 
+ * @example Basic Usage
+ * ```typescript
+ * import { LeRobotInferenceServerClient, CreateSessionRequest } from '@lerobot-arena/inference-server-client';
+ * 
+ * const client = new LeRobotInferenceServerClient('http://localhost:8001');
+ * 
+ * // Create and start a session
+ * const sessionRequest: CreateSessionRequest = {
+ *   session_id: 'my-robot-01',
+ *   policy_path: './checkpoints/act_so101_beyond',
+ *   camera_names: ['front', 'wrist'],
+ *   arena_server_url: 'http://localhost:8000'
+ * };
+ * 
+ * const session = await client.createSession(sessionRequest);
+ * await client.startInference('my-robot-01');
+ * 
+ * // Monitor session
+ * const status = await client.getSessionStatus('my-robot-01');
+ * console.log(`Session status: ${status.status}`);
+ * ```
+ */
+
+// Export all generated types and services from OpenAPI
+export * from './generated';
+
+// Import what we need for the convenience wrapper
+import { 
+  client,
+  createSessionSessionsPost,
+  listSessionsSessionsGet,
+  getSessionStatusSessionsSessionIdGet,
+  startInferenceSessionsSessionIdStartPost,
+  stopInferenceSessionsSessionIdStopPost,
+  restartInferenceSessionsSessionIdRestartPost,
+  deleteSessionSessionsSessionIdDelete,
+  healthCheckHealthGet,
+  getSystemInfoDebugSystemGet,
+  debugResetSessionDebugSessionsSessionIdResetPost,
+  getSessionQueueInfoDebugSessionsSessionIdQueueGet
+} from './generated';
+
+import type {
+  CreateSessionRequest,
+  CreateSessionResponse,
+  SessionStatusResponse
+} from './generated';
+
+/**
+ * LeRobot Arena Inference Server Client
+ * 
+ * A convenience wrapper around the generated OpenAPI client that provides
+ * a simpler interface for common operations while maintaining full type safety.
+ */
+export class LeRobotInferenceServerClient {
+  private baseUrl: string;
+
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+    // Configure the generated client with the base URL
+    client.setConfig({ baseUrl });
+  }
+
+  /**
+   * Check if the inference server is healthy and responding
+   */
+  async isHealthy(): Promise<boolean> {
+    try {
+      const response = await healthCheckHealthGet();
+      return !response.error;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get detailed server health information
+   */
+  async getHealth() {
+    const response = await healthCheckHealthGet();
+    if (response.error) {
+      throw new Error(`Health check failed: ${JSON.stringify(response.error)}`);
+    }
+    return response.data;
+  }
+
+  /**
+   * Create a new inference session
+   */
+  async createSession(request: CreateSessionRequest): Promise<CreateSessionResponse> {
+    const response = await createSessionSessionsPost({
+      body: request
+    });
+
+    if (response.error) {
+      throw new Error(`Failed to create session: ${JSON.stringify(response.error)}`);
+    }
+
+    return response.data!;
+  }
+
+  /**
+   * List all active sessions
+   */
+  async listSessions(): Promise<SessionStatusResponse[]> {
+    const response = await listSessionsSessionsGet();
+    if (response.error) {
+      throw new Error(`Failed to list sessions: ${JSON.stringify(response.error)}`);
+    }
+    return response.data!;
+  }
+
+  /**
+   * Get detailed status of a specific session
+   */
+  async getSessionStatus(sessionId: string): Promise<SessionStatusResponse> {
+    const response = await getSessionStatusSessionsSessionIdGet({
+      path: { session_id: sessionId }
+    });
+
+    if (response.error) {
+      throw new Error(`Failed to get session status: ${JSON.stringify(response.error)}`);
+    }
+
+    return response.data!;
+  }
+
+  /**
+   * Start inference for a session
+   */
+  async startInference(sessionId: string): Promise<void> {
+    const response = await startInferenceSessionsSessionIdStartPost({
+      path: { session_id: sessionId }
+    });
+
+    if (response.error) {
+      throw new Error(`Failed to start inference: ${JSON.stringify(response.error)}`);
+    }
+  }
+
+  /**
+   * Stop inference for a session
+   */
+  async stopInference(sessionId: string): Promise<void> {
+    const response = await stopInferenceSessionsSessionIdStopPost({
+      path: { session_id: sessionId }
+    });
+
+    if (response.error) {
+      throw new Error(`Failed to stop inference: ${JSON.stringify(response.error)}`);
+    }
+  }
+
+  /**
+   * Restart inference for a session
+   */
+  async restartInference(sessionId: string): Promise<void> {
+    const response = await restartInferenceSessionsSessionIdRestartPost({
+      path: { session_id: sessionId }
+    });
+
+    if (response.error) {
+      throw new Error(`Failed to restart inference: ${JSON.stringify(response.error)}`);
+    }
+  }
+
+  /**
+   * Delete a session and clean up all resources
+   */
+  async deleteSession(sessionId: string): Promise<void> {
+    const response = await deleteSessionSessionsSessionIdDelete({
+      path: { session_id: sessionId }
+    });
+
+    if (response.error) {
+      throw new Error(`Failed to delete session: ${JSON.stringify(response.error)}`);
+    }
+  }
+
+  /**
+   * Wait for a session to reach a specific status
+   */
+  async waitForSessionStatus(
+    sessionId: string, 
+    targetStatus: string, 
+    timeoutMs: number = 30000
+  ): Promise<SessionStatusResponse> {
+    const startTime = Date.now();
+    
+    while (Date.now() - startTime < timeoutMs) {
+      const status = await this.getSessionStatus(sessionId);
+      if (status.status === targetStatus) {
+        return status;
+      }
+      
+      // Wait 1 second before checking again
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    
+    throw new Error(`Timeout waiting for session ${sessionId} to reach status ${targetStatus}`);
+  }
+
+  /**
+   * Convenience method to create a session and start inference in one call
+   */
+  async createAndStartSession(request: CreateSessionRequest): Promise<{
+    session: CreateSessionResponse;
+    status: SessionStatusResponse;
+  }> {
+    const session = await this.createSession(request);
+    await this.startInference(request.session_id);
+    
+    // Wait for it to be running
+    const status = await this.waitForSessionStatus(request.session_id, 'running');
+    
+    return { session, status };
+  }
+
+  /**
+   * Get system information for debugging
+   */
+  async getSystemInfo() {
+    const response = await getSystemInfoDebugSystemGet();
+    if (response.error) {
+      throw new Error(`Failed to get system info: ${JSON.stringify(response.error)}`);
+    }
+    return response.data;
+  }
+
+  /**
+   * Reset a session's internal state (debug method)
+   */
+  async debugResetSession(sessionId: string): Promise<void> {
+    const response = await debugResetSessionDebugSessionsSessionIdResetPost({
+      path: { session_id: sessionId }
+    });
+
+    if (response.error) {
+      throw new Error(`Failed to reset session: ${JSON.stringify(response.error)}`);
+    }
+  }
+
+  /**
+   * Get detailed information about a session's action queue
+   */
+  async getSessionQueueInfo(sessionId: string) {
+    const response = await getSessionQueueInfoDebugSessionsSessionIdQueueGet({
+      path: { session_id: sessionId }
+    });
+
+    if (response.error) {
+      throw new Error(`Failed to get queue info: ${JSON.stringify(response.error)}`);
+    }
+    return response.data;
+  }
+}
+
+// Convenience function to create a client
+export function createClient(baseUrl: string): LeRobotInferenceServerClient {
+  return new LeRobotInferenceServerClient(baseUrl);
+}
+
+// Export the old class name for backward compatibility
+export const LeRobotAIServerClient = LeRobotInferenceServerClient; 

client/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ES2022", "DOM"],
+    "target": "ES2022",
+    "module": "es2022",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "verbatimModuleSyntax": true,
+    "noEmit": false,
+    "outDir": "./dist",
+    
+    // Declaration files
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "declarationMap": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

external/RobotHub-TransportServer

@@ -0,0 +1 @@
+Subproject commit 8aedc84a7635fc0cbbd3a0671a5e1cf50616dad0

external/lerobot

@@ -0,0 +1 @@
+Subproject commit a5727e37b4ff405f9d8de424e07dcc441aa2c82f

launch_simple.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""
+Main launcher for the Inference Server
+
+Integrated application that runs both FastAPI and Gradio on the same port.
+- FastAPI API available at /api with full documentation
+- Gradio UI available at the root path /
+- Single process, single port - perfect for deployment!
+"""
+
+import sys
+from pathlib import Path
+
+# Add the src directory to Python path
+src_path = Path(__file__).parent / "src"
+sys.path.insert(0, str(src_path))
+
+from inference_server.simple_integrated import launch_simple_integrated_app
+
+if __name__ == "__main__":
+    print("🤖 Inference Server (Integrated)")
+    print("FastAPI + Gradio on the same port!")
+    print("API Documentation available at /api/docs")
+    print("Press Ctrl+C to stop")
+    print("-" * 50)
+
+    # Parse simple command line args
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Launch integrated Inference Server with FastAPI + Gradio"
+    )
+    parser.add_argument("--host", default="localhost", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=7860, help="Port to bind to")
+    parser.add_argument(
+        "--share", action="store_true", help="Create public Gradio link"
+    )
+
+    args = parser.parse_args()
+
+    print(f"🚀 Starting on {args.host}:{args.port}")
+    print(f"🎨 Gradio UI: http://{args.host}:{args.port}/")
+    print(f"📖 API Docs: http://{args.host}:{args.port}/api/docs")
+    print()
+
+    launch_simple_integrated_app(host=args.host, port=args.port, share=args.share)

openapi.json

@@ -0,0 +1,692 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "LeRobot Arena AI Server",
+    "summary": "ACT Model Inference Server for Real-time Robot Control",
+    "description": "\n        ## LeRobot Arena AI Server\n\n        This server provides **ACT (Action Chunking Transformer)** model inference for robotics applications.\n        It uses the LeRobot Arena communication system with multiple rooms per session for:\n\n        ### Core Features:\n        - 🎥 **Multi-camera support**: Arbitrary number of camera streams with unique names\n        - 🤖 **Joint control**: Normalized joint value handling (-100 to +100 range)\n        - 🔄 **Real-time inference**: Optimized for robotics control loops\n        - 📊 **Session management**: Multiple concurrent inference sessions\n        - 🛠️ **Debug endpoints**: Comprehensive monitoring and debugging tools\n\n        ### Communication Architecture:\n        1. **Camera rooms**: Receives video streams from robot cameras (supports multiple cameras)\n        2. **Joint input room**: Receives current robot joint positions (**NORMALIZED VALUES**)\n        3. **Joint output room**: Sends predicted joint commands (**NORMALIZED VALUES**)\n\n        ### Supported Cameras:\n        Each camera stream has a unique name (e.g., \"front\", \"wrist\", \"overhead\") \n        and all streams are synchronized for inference.\n\n        ### Joint Value Convention:\n        - All joint inputs/outputs use **NORMALIZED VALUES**\n        - Range: -100 to +100 for most joints, 0 to 100 for gripper\n        - Matches training data format exactly\n\n        ### Getting Started:\n        1. Create a session with your trained ACT model\n        2. Connect your robot to the generated rooms\n        3. Start inference to begin real-time control\n        ",
+    "version": "1.0.0",
+    "contact": {
+      "name": "LeRobot Arena Team",
+      "url": "https://github.com/huggingface/lerobot"
+    },
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0.html"
+    },
+    "x-logo": {
+      "url": "https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.png",
+      "altText": "LeRobot Logo"
+    }
+  },
+  "paths": {
+    "/": {
+      "get": {
+        "tags": [
+          "Health"
+        ],
+        "summary": "Root",
+        "description": "Health check endpoint.",
+        "operationId": "root__get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/health": {
+      "get": {
+        "tags": [
+          "Health"
+        ],
+        "summary": "Health Check",
+        "description": "Detailed health check.",
+        "operationId": "health_check_health_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions": {
+      "get": {
+        "tags": [
+          "Sessions"
+        ],
+        "summary": "List Sessions",
+        "description": "List all sessions.",
+        "operationId": "list_sessions_sessions_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "items": {
+                    "$ref": "#/components/schemas/SessionStatusResponse"
+                  },
+                  "type": "array",
+                  "title": "Response List Sessions Sessions Get"
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "Sessions"
+        ],
+        "summary": "Create Session",
+        "description": "Create a new inference session.\n\nIf workspace_id is provided, all rooms will be created in that workspace.\nIf workspace_id is not provided, a new workspace will be generated automatically.\nAll rooms for a session (cameras + joints) are always created in the same workspace.",
+        "operationId": "create_session_sessions_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateSessionRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CreateSessionResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions/{session_id}": {
+      "get": {
+        "tags": [
+          "Sessions"
+        ],
+        "summary": "Get Session Status",
+        "description": "Get status of a specific session.",
+        "operationId": "get_session_status_sessions__session_id__get",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SessionStatusResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "Sessions"
+        ],
+        "summary": "Delete Session",
+        "description": "Delete a session.",
+        "operationId": "delete_session_sessions__session_id__delete",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions/{session_id}/start": {
+      "post": {
+        "tags": [
+          "Control"
+        ],
+        "summary": "Start Inference",
+        "description": "Start inference for a session.",
+        "operationId": "start_inference_sessions__session_id__start_post",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions/{session_id}/stop": {
+      "post": {
+        "tags": [
+          "Control"
+        ],
+        "summary": "Stop Inference",
+        "description": "Stop inference for a session.",
+        "operationId": "stop_inference_sessions__session_id__stop_post",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sessions/{session_id}/restart": {
+      "post": {
+        "tags": [
+          "Control"
+        ],
+        "summary": "Restart Inference",
+        "description": "Restart inference for a session.",
+        "operationId": "restart_inference_sessions__session_id__restart_post",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/debug/system": {
+      "get": {
+        "tags": [
+          "Debug"
+        ],
+        "summary": "Get System Info",
+        "description": "Get system information for debugging.",
+        "operationId": "get_system_info_debug_system_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/debug/logs": {
+      "get": {
+        "tags": [
+          "Debug"
+        ],
+        "summary": "Get Recent Logs",
+        "description": "Get recent log entries for debugging.",
+        "operationId": "get_recent_logs_debug_logs_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/debug/sessions/{session_id}/reset": {
+      "post": {
+        "tags": [
+          "Debug"
+        ],
+        "summary": "Debug Reset Session",
+        "description": "Reset a session's internal state for debugging.",
+        "operationId": "debug_reset_session_debug_sessions__session_id__reset_post",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/debug/sessions/{session_id}/queue": {
+      "get": {
+        "tags": [
+          "Debug"
+        ],
+        "summary": "Get Session Queue Info",
+        "description": "Get detailed information about a session's action queue.",
+        "operationId": "get_session_queue_info_debug_sessions__session_id__queue_get",
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Session Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "CreateSessionRequest": {
+        "properties": {
+          "session_id": {
+            "type": "string",
+            "title": "Session Id"
+          },
+          "policy_path": {
+            "type": "string",
+            "title": "Policy Path"
+          },
+          "camera_names": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array",
+            "title": "Camera Names",
+            "default": [
+              "front"
+            ]
+          },
+          "arena_server_url": {
+            "type": "string",
+            "title": "Arena Server Url",
+            "default": "http://localhost:8000"
+          },
+          "workspace_id": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Workspace Id"
+          }
+        },
+        "type": "object",
+        "required": [
+          "session_id",
+          "policy_path"
+        ],
+        "title": "CreateSessionRequest"
+      },
+      "CreateSessionResponse": {
+        "properties": {
+          "workspace_id": {
+            "type": "string",
+            "title": "Workspace Id"
+          },
+          "camera_room_ids": {
+            "additionalProperties": {
+              "type": "string"
+            },
+            "type": "object",
+            "title": "Camera Room Ids"
+          },
+          "joint_input_room_id": {
+            "type": "string",
+            "title": "Joint Input Room Id"
+          },
+          "joint_output_room_id": {
+            "type": "string",
+            "title": "Joint Output Room Id"
+          }
+        },
+        "type": "object",
+        "required": [
+          "workspace_id",
+          "camera_room_ids",
+          "joint_input_room_id",
+          "joint_output_room_id"
+        ],
+        "title": "CreateSessionResponse"
+      },
+      "HTTPValidationError": {
+        "properties": {
+          "detail": {
+            "items": {
+              "$ref": "#/components/schemas/ValidationError"
+            },
+            "type": "array",
+            "title": "Detail"
+          }
+        },
+        "type": "object",
+        "title": "HTTPValidationError"
+      },
+      "SessionStatusResponse": {
+        "properties": {
+          "session_id": {
+            "type": "string",
+            "title": "Session Id"
+          },
+          "status": {
+            "type": "string",
+            "title": "Status"
+          },
+          "policy_path": {
+            "type": "string",
+            "title": "Policy Path"
+          },
+          "camera_names": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array",
+            "title": "Camera Names"
+          },
+          "workspace_id": {
+            "type": "string",
+            "title": "Workspace Id"
+          },
+          "rooms": {
+            "additionalProperties": true,
+            "type": "object",
+            "title": "Rooms"
+          },
+          "stats": {
+            "additionalProperties": true,
+            "type": "object",
+            "title": "Stats"
+          },
+          "inference_stats": {
+            "anyOf": [
+              {
+                "additionalProperties": true,
+                "type": "object"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Inference Stats"
+          },
+          "error_message": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Error Message"
+          }
+        },
+        "type": "object",
+        "required": [
+          "session_id",
+          "status",
+          "policy_path",
+          "camera_names",
+          "workspace_id",
+          "rooms",
+          "stats"
+        ],
+        "title": "SessionStatusResponse"
+      },
+      "ValidationError": {
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          }
+        },
+        "type": "object",
+        "required": [
+          "loc",
+          "msg",
+          "type"
+        ],
+        "title": "ValidationError"
+      }
+    },
+    "securitySchemes": {
+      "BearerAuth": {
+        "type": "http",
+        "scheme": "bearer",
+        "bearerFormat": "JWT"
+      },
+      "ApiKeyAuth": {
+        "type": "apiKey",
+        "in": "header",
+        "name": "X-API-Key"
+      }
+    }
+  },
+  "servers": [
+    {
+      "url": "http://localhost:8001",
+      "description": "Development server"
+    },
+    {
+      "url": "https://your-production-server.com",
+      "description": "Production server"
+    }
+  ],
+  "tags": [
+    {
+      "name": "Health",
+      "description": "Health check and server status endpoints"
+    },
+    {
+      "name": "Sessions",
+      "description": "Inference session management - create, control, and monitor AI sessions"
+    },
+    {
+      "name": "Control",
+      "description": "Session control operations - start, stop, restart inference"
+    },
+    {
+      "name": "Debug",
+      "description": "Debug and monitoring endpoints for system diagnostics"
+    }
+  ]
+}

pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "inference-server"
+version = "0.1.0"
+description = "ACT Model Inference Server for Real-time Robot Control"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "aiofiles>=24.1.0",
+    "aiortc>=1.13.0",
+    "av>=14.4.0",
+    "einops>=0.7.0",
+    "fastapi>=0.115.12",
+    "gradio>=5.34.2",
+    "httpx>=0.28.1",
+    "huggingface-hub>=0.32.4",
+    "imageio[ffmpeg]>=2.37.0",
+    "lerobot",
+    "robohub-transport-server-client",
+    "numpy>=1.26.4",
+    "opencv-python>=4.11.0.86",
+    "opencv-python-headless>=4.11.0.86",
+    "psutil>=7.0.0",
+    "pydantic>=2.11.5",
+    "python-multipart>=0.0.20",
+    "torch>=2.2.2",
+    "torchvision>=0.17.2",
+    "tqdm>=4.67.1",
+    "transformers>=4.52.4",
+    "uvicorn[standard]>=0.34.3",
+    "websockets>=15.0.1",
+]
+
+[dependency-groups]
+dev = [
+    "httpx>=0.28.1",
+    "pytest>=8.4.0",
+    "pytest-asyncio>=1.0.0",
+    "pytest-cov>=6.1.1",
+]
+
+[tool.uv.sources]
+robohub-transport-server-client = { path = "../transport-server/client/python", editable = true }
+lerobot = { path = "./external/lerobot", editable = false }

src/inference_server.egg-info/PKG-INFO

@@ -0,0 +1,347 @@
+Metadata-Version: 2.4
+Name: inference-server
+Version: 0.1.0
+Summary: ACT Model Inference Server for Real-time Robot Control
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aiofiles>=24.1.0
+Requires-Dist: aiortc>=1.13.0
+Requires-Dist: av>=14.4.0
+Requires-Dist: einops>=0.7.0
+Requires-Dist: fastapi>=0.115.12
+Requires-Dist: gradio>=5.34.2
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: huggingface-hub>=0.32.4
+Requires-Dist: imageio[ffmpeg]>=2.37.0
+Requires-Dist: lerobot
+Requires-Dist: lerobot-arena-client
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: opencv-python>=4.11.0.86
+Requires-Dist: opencv-python-headless>=4.11.0.86
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: pydantic>=2.11.5
+Requires-Dist: python-multipart>=0.0.20
+Requires-Dist: torch>=2.2.2
+Requires-Dist: torchvision>=0.17.2
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: transformers>=4.52.4
+Requires-Dist: uvicorn[standard]>=0.34.3
+Requires-Dist: websockets>=15.0.1
+
+---
+title: LeRobot Arena - AI Inference Server
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+suggested_hardware: t4-small
+suggested_storage: medium
+short_description: Real-time ACT model inference server for robot control
+tags:
+  - robotics
+  - ai
+  - inference
+  - control
+  - act-model
+  - transformer
+  - real-time
+  - gradio
+  - fastapi
+  - computer-vision
+pinned: false
+fullWidth: true
+---
+
+# Inference Server
+
+🤖 **Real-time ACT Model Inference Server for Robot Control**
+
+This server provides ACT (Action Chunking Transformer) model inference for robotics applications using the transport server communication system. It includes a user-friendly Gradio web interface for easy setup and management.
+
+## ✨ Features
+
+- **Real-time AI Inference**: Run ACT models for robot control at 20Hz control frequency
+- **Multi-Camera Support**: Handle multiple camera streams with different names
+- **Web Interface**: User-friendly Gradio UI for setup and monitoring
+- **Session Management**: Create, start, stop, and monitor inference sessions
+- **Automatic Timeout**: Sessions automatically cleanup after 10 minutes of inactivity
+- **Debug Tools**: Built-in debugging and monitoring endpoints
+- **Flexible Configuration**: Support for custom model paths, camera configurations
+- **No External Dependencies**: Direct Python execution without subprocess calls
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.12+
+- UV package manager (recommended)
+- Trained ACT model
+- Transport server running
+
+### 1. Installation
+
+```bash
+cd backend/ai-server
+
+# Install dependencies using uv (recommended)
+uv sync
+
+# Or using pip
+pip install -e .
+```
+
+### 2. Launch the Application
+
+#### **🚀 Simple Integrated Mode (Recommended)**
+```bash
+# Everything runs in one process - no subprocess issues!
+python launch_simple.py
+
+# Or using the CLI
+python -m inference_server.cli --simple
+```
+
+This will:
+- Run everything on `http://localhost:7860`
+- Direct session management (no HTTP API calls)
+- No external subprocess dependencies
+- Most robust and simple deployment!
+
+#### **🔧 Development Mode (Separate Processes)**
+```bash
+# Traditional approach with separate server and UI
+python -m inference_server.cli
+```
+
+This will:
+- Start the AI server on `http://localhost:8001`
+- Launch the Gradio UI on `http://localhost:7860`
+- Better for development and debugging
+
+### 3. Using the Web Interface
+
+1. **Check Server Status**: The interface will automatically check if the AI server is running
+2. **Configure Your Robot**: Enter your model path and camera setup
+3. **Create & Start Session**: Click the button to set up AI control
+4. **Monitor Performance**: Use the status panel to monitor inference
+
+## 🎯 Workflow Guide
+
+### Step 1: AI Server
+- The server status will be displayed at the top
+- Click "Start Server" if it's not already running
+- Use "Check Status" to verify connectivity
+
+### Step 2: Set Up Robot AI
+- **Session Name**: Give your session a unique name (e.g., "my-robot-01")
+- **AI Model Path**: Path to your trained ACT model (e.g., "./checkpoints/act_so101_beyond")
+- **Camera Names**: Comma-separated list of camera names (e.g., "front,wrist,overhead")
+- Click "Create & Start AI Control" to begin
+
+### Step 3: Control Session
+- The session ID will be auto-filled after creation
+- Use Start/Stop buttons to control inference
+- Click "Status" to see detailed performance metrics
+
+## 🛠️ Advanced Usage
+
+### CLI Options
+
+```bash
+# Simple integrated mode (recommended)
+python -m inference_server.cli --simple
+
+# Development mode (separate processes)
+python -m inference_server.cli
+
+# Launch only the server
+python -m inference_server.cli --server-only
+
+# Launch only the UI (server must be running separately)  
+python -m inference_server.cli --ui-only
+
+# Custom ports
+python -m inference_server.cli --server-port 8002 --ui-port 7861
+
+# Enable public sharing
+python -m inference_server.cli --share
+
+# For deployment (recommended)
+python -m inference_server.cli --simple --host 0.0.0.0 --share
+```
+
+### API Endpoints
+
+The server provides a REST API for programmatic access:
+
+- `GET /health` - Server health check
+- `POST /sessions` - Create new session
+- `GET /sessions` - List all sessions
+- `GET /sessions/{id}` - Get session details
+- `POST /sessions/{id}/start` - Start inference
+- `POST /sessions/{id}/stop` - Stop inference
+- `POST /sessions/{id}/restart` - Restart inference
+- `DELETE /sessions/{id}` - Delete session
+
+#### Debug Endpoints
+- `GET /debug/system` - System information (CPU, memory, GPU)
+- `GET /debug/sessions/{id}/queue` - Action queue details
+- `POST /debug/sessions/{id}/reset` - Reset session state
+
+### Configuration
+
+#### Joint Value Convention
+- All joint inputs/outputs use **NORMALIZED VALUES**
+- Most joints: -100 to +100 (RANGE_M100_100)
+- Gripper: 0 to 100 (RANGE_0_100)
+- This matches the training data format exactly
+
+#### Camera Support
+- Supports arbitrary number of camera streams
+- Each camera has a unique name (e.g., "front", "wrist", "overhead")
+- All camera streams are synchronized for inference
+- Images expected in RGB format, uint8 [0-255]
+
+## 📊 Monitoring
+
+### Session Status Indicators
+- 🟢 **Running**: Inference active and processing
+- 🟡 **Ready**: Session created but inference not started
+- 🔴 **Stopped**: Inference stopped
+- 🟠 **Initializing**: Session being set up
+
+### Smart Session Control
+The UI now provides intelligent feedback:
+- ℹ️ **Already Running**: When trying to start a running session
+- ℹ️ **Already Stopped**: When trying to stop a stopped session
+- 💡 **Smart Suggestions**: Context-aware tips based on current status
+
+### Performance Metrics
+- **Inferences**: Total number of model inferences performed
+- **Commands Sent**: Joint commands sent to robot
+- **Queue Length**: Actions waiting in the queue
+- **Errors**: Number of errors encountered
+- **Data Flow**: Images and joint states received
+
+## 🐳 Docker Usage
+
+### Build the Image
+```bash
+cd services/inference-server
+docker build -t inference-server .
+```
+
+### Run the Container
+```bash
+# Basic usage
+docker run -p 7860:7860 inference-server
+
+# With environment variables
+docker run -p 7860:7860 \
+  -e DEFAULT_ARENA_SERVER_URL=http://your-server.com \
+  -e DEFAULT_MODEL_PATH=./checkpoints/your-model \
+  inference-server
+
+# With GPU support
+docker run --gpus all -p 7860:7860 inference-server
+```
+
+## 🔧 Troubleshooting
+
+
+
+### Common Issues
+
+1. **Server Won't Start**
+   - Check if port 8001 is available
+   - Verify model path exists and is accessible
+   - Check dependencies are installed correctly
+
+2. **Session Creation Fails**
+   - Verify model path is correct
+   - Check Arena server is running on specified URL
+   - Ensure camera names match your robot configuration
+
+3. **Poor Performance**
+   - Monitor system resources in the debug panel
+   - Check if GPU is being used for inference
+   - Verify control/inference frequency settings
+
+4. **Connection Issues**
+   - Verify Arena server URL is correct
+   - Check network connectivity
+   - Ensure workspace/room IDs are valid
+
+### Debug Mode
+
+Enable debug mode for detailed logging:
+
+```bash
+uv run python -m lerobot_arena_ai_server.cli --debug
+```
+
+### System Requirements
+
+- **CPU**: Multi-core recommended for 30Hz control
+- **Memory**: 8GB+ RAM recommended
+- **GPU**: CUDA-compatible GPU for fast inference (optional but recommended)
+- **Network**: Stable connection to Arena server
+
+## 📚 Architecture
+
+### Integrated Mode (Recommended)
+```
+┌─────────────────────────────────────┐    ┌─────────────────┐
+│        Single Application           │    │  LeRobot Arena  │
+│  ┌─────────────┐  ┌─────────────┐   │◄──►│   (Port 8000)   │
+│  │ Gradio UI   │  │ AI Server   │   │    └─────────────────┘
+│  │    (/)      │  │  (/api/*)   │   │             │
+│  └─────────────┘  └─────────────┘   │             │
+│       (Port 7860)                   │        Robot/Cameras
+└─────────────────────────────────────┘
+           │
+      Web Browser
+```
+
+### Development Mode
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Gradio UI     │    │   AI Server     │    │  LeRobot Arena  │
+│   (Port 7860)   │◄──►│   (Port 8001)   │◄──►│   (Port 8000)   │
+└─────────────────┘    └─────────────────┘    └───────────────���─┘
+         │                       │                       │
+         │                       │                       │
+    Web Browser              ACT Model              Robot/Cameras
+                             Inference
+```
+
+### Data Flow
+
+1. **Camera Data**: Robot cameras → Arena → AI Server
+2. **Joint State**: Robot joints → Arena → AI Server  
+3. **AI Inference**: Images + Joint State → ACT Model → Actions
+4. **Control Commands**: Actions → Arena → Robot
+
+### Session Lifecycle
+
+1. **Create**: Set up rooms in Arena, load ACT model
+2. **Start**: Begin inference loop (3Hz) and control loop (30Hz)
+3. **Running**: Process camera/joint data, generate actions
+4. **Stop**: Pause inference, maintain connections
+5. **Delete**: Clean up resources, disconnect from Arena
+
+## 🤝 Contributing
+
+1. Follow the existing code style
+2. Add tests for new features
+3. Update documentation
+4. Submit pull requests
+
+## 📄 License
+
+This project follows the same license as the parent LeRobot Arena project.
+
+---
+
+For more information, see the [LeRobot Arena documentation](../../README.md).

src/inference_server.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+src/inference_server/__init__.py
+src/inference_server/cli.py
+src/inference_server/export_openapi.py
+src/inference_server/main.py
+src/inference_server/session_manager.py
+src/inference_server/simple_integrated.py
+src/inference_server/ui.py
+src/inference_server.egg-info/PKG-INFO
+src/inference_server.egg-info/SOURCES.txt
+src/inference_server.egg-info/dependency_links.txt
+src/inference_server.egg-info/requires.txt
+src/inference_server.egg-info/top_level.txt
+src/inference_server/models/__init__.py
+src/inference_server/models/act_inference.py
+src/inference_server/models/base_inference.py
+src/inference_server/models/diffusion_inference.py
+src/inference_server/models/joint_config.py
+src/inference_server/models/pi0_inference.py
+src/inference_server/models/pi0fast_inference.py
+src/inference_server/models/smolvla_inference.py

src/inference_server.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src/inference_server.egg-info/requires.txt

@@ -0,0 +1,23 @@
+aiofiles>=24.1.0
+aiortc>=1.13.0
+av>=14.4.0
+einops>=0.7.0
+fastapi>=0.115.12
+gradio>=5.34.2
+httpx>=0.28.1
+huggingface-hub>=0.32.4
+imageio[ffmpeg]>=2.37.0
+lerobot
+lerobot-arena-client
+numpy>=1.26.4
+opencv-python>=4.11.0.86
+opencv-python-headless>=4.11.0.86
+psutil>=7.0.0
+pydantic>=2.11.5
+python-multipart>=0.0.20
+torch>=2.2.2
+torchvision>=0.17.2
+tqdm>=4.67.1
+transformers>=4.52.4
+uvicorn[standard]>=0.34.3
+websockets>=15.0.1

src/inference_server.egg-info/top_level.txt

@@ -0,0 +1 @@
+inference_server

src/inference_server/__init__.py

@@ -0,0 +1,30 @@
+try:
+    from .export_openapi import export_openapi_schema
+except ImportError:
+    export_openapi_schema = None
+
+try:
+    from .main import app
+except ImportError:
+    app = None
+
+from .session_manager import InferenceSession, SessionManager
+
+try:
+    from .ui import launch_ui
+except ImportError:
+    launch_ui = None
+
+__version__ = "0.1.0"
+__all__ = [
+    "InferenceSession",
+    "SessionManager",
+]
+
+# Add optional exports if available
+if app is not None:
+    __all__.append("app")
+if export_openapi_schema is not None:
+    __all__.append("export_openapi_schema")
+if launch_ui is not None:
+    __all__.append("launch_ui")