# Core Infrastructure

## Systems

This infrastructure provides the foundation for fluid, natural interaction between users and agents across the desktop environment.

### Narration System

The voice that brings agents to life:

* Real-time text-to-speech generation
* Voice model management
* Audio stream handling
* Emotion and tone control
* Performance optimization

```python
class VoiceHandler:
    async def generate_and_play(self, text: str):
        """Generate and play voice response"""
        audio = await self.elevenlabs_client.generate(
            text=text,
            voice_id=self.voice_id,
            model=self.voice_model
        )
        await self.play_audio(audio)
```

### Voice Command System

Natural language interface for agents:

* Voice input processing
* Command recognition
* Context awareness
* Multi-command chaining
* Real-time response

```python
class VoiceCommandSystem:
    def __init__(self, config):
        self.client = AsyncOpenAI(api_key=config['api_keys']['openai'])
        self.sample_rate = 16000
        self.recording = False
        self.chunks = []

    async def start_recording(self):
        self.recording = True
        self.stream = sd.InputStream(
            channels=1,
            samplerate=self.sample_rate,
            callback=self._audio_callback
        )
        self.stream.start()

    async def stop_and_transcribe(self):
        self.recording = False
        self.stream.stop()
        audio_data = np.concatenate(self.chunks)
        
        # Send to Whisper API for transcription
        response = await self.client.audio.transcriptions.create(
            model="whisper-1",
            file=("audio.wav", self._prepare_audio(audio_data))
        )
        return response.text
```

### Command Acceleration System

Supercharging agent actions:

* Hotkey management
* Command shortcuts
* Action chaining
* Quick access menus
* Custom command flows

```python
class CommandAccelerator:
    def __init__(self, config):
        self.client = AsyncOpenAI(api_key=config['api_keys']['openai'])
        self.command_history = []

    async def enhance_command(self, command: str) -> str:
        response = await self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "Enhance this command:"},
                {"role": "user", "content": command}
            ],
            temperature=0.7
        )
        enhanced = response.choices[0].message.content
        self.command_history.append((command, enhanced))
        return enhanced

    def get_command_suggestions(self, partial_command: str) -> list[str]:
        return [cmd for cmd, _ in self.command_history 
                if cmd.startswith(partial_command)]
```

### Avatar Management System

Visual representation control:

* Dynamic avatar states
* Emotion visualization
* Real-time animation
* Style customization
* Visual feedback

```python
class AvatarManager:
    def __init__(self):
        self.current_avatar = None
        self.avatars = {}
        self.observers = []

    def set_avatar(self, avatar_id: str):
        if avatar_id in self.avatars:
            self.current_avatar = self.avatars[avatar_id]
            self._notify_observers()

    def update_avatar_state(self, state: str):
        if self.current_avatar:
            self.current_avatar.state = state
            self._notify_observers()

    def _notify_observers(self):
        for observer in self.observers:
            observer.on_avatar_update(self.current_avatar)
```

### UI System

Modern, responsive interface:

* Circular video avatar
* Command input
* Region selection
* Status indicators

```python
def init_ui(self):
    """Initialize the user interface"""
    # Set window size with scaling
    base_width = 200
    base_height = 380
    self.resize(
        int(base_width * self.scaling_factor * 0.5),
        int(base_height * self.scaling_factor * 0.5)
    )
    
    # Setup window properties
    self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
    self.setAttribute(Qt.WA_TranslucentBackground)
```

### Notification System

Seamless user updates:

* Animated notifications
* Progress tracking
* Status updates

```python
class NotificationWindow(QWidget):
    def show_message(self, message: str):
        """Show animated notification"""
        self.message_label.setText(message)
        self.animation.start()
        self.progress_timer.start()
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://agenttank.gitbook.io/agenttank/developers/core-infrastructure.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.