Voice Agent

1import { io } from 'socket.io-client';
2
3// Connect to Voice Agent with namespace
4const socket = io('wss://api.selamgpt.com/v1/audio/agent', {
5  query: {
6
7    api_key: 'your-api-key',
8    voice: 'mekdes'  // Amharic voice
9  },
10  transports: ['websocket']
11});
12
13// Handle connection
14socket.on('connected', (data) => {
15  console.log('Connected:', data);
16  // { status: 'connected', sid: '...', voice: 'mekdes', message: '...' }
17  
18  // Start session
19  socket.emit('start_session', {
20    voice: 'mekdes',
21    language: 'am',
22    // Note: For Amharic, use mekdes/ameha/betty. GPT Audio voices only support English.
23    instructions: 'You are a helpful voice assistant.'
24  });
25});
26
27// Handle session started
28socket.on('session_started', (data) => {
29  console.log('Session started:', data);
30  // Now you can send audio chunks
31});
32
33// Handle errors
34socket.on('error', (error) => {
35  console.error('Error:', error);
36});

1// Interrupt current speech
2socket.emit('control', { action: 'interrupt' });
3
4// Pause listening
5socket.emit('control', { action: 'stop_listening' });
6
7// Resume listening
8socket.emit('control', { action: 'start_listening' });
9
10// Handle control acknowledgment
11socket.on('control_ack', (data) => {
12  console.log('Control executed:', data);
13  // { action: 'interrupt', status: 'executed' }
14});

1import { io } from 'socket.io-client';
2
3class VoiceAgent {
4  constructor(apiKey) {
5    this.apiKey = apiKey;
6    this.socket = null;
7    this.mediaRecorder = null;
8    this.isRecording = false;
9  }
10
11  connect(voice = 'mekdes') {
12    this.socket = io('wss://api.selamgpt.com/v1/audio/agent', {
13      query: {
14        api_key: this.apiKey,
15        voice: voice
16      },
17      transports: ['websocket']
18    });
19
20    this.setupEventHandlers();
21  }
22
23  setupEventHandlers() {
24    this.socket.on('connected', (data) => {
25      console.log('Connected:', data);
26      this.startSession();
27    });
28
29    this.socket.on('session_started', (data) => {
30      console.log('Session started:', data);
31      console.log('Ready for Push-to-Talk');
32    });
33
34    this.socket.on('transcription', (data) => {
35      console.log('User:', data.text);
36    });
37
38    this.socket.on('response', (data) => {
39      console.log('AI:', data.text);
40    });
41
42    this.socket.on('audio_chunk', (data) => {
43      this.playAudioChunk(data.audio);
44    });
45
46    this.socket.on('error', (error) => {
47      console.error('Error:', error);
48    });
49  }
50
51  startSession() {
52    this.socket.emit('start_session', {
53      voice: 'mekdes',
54      language: 'am',
55      instructions: 'You are a helpful voice assistant.',
56      vad_threshold: 600,
57      interrupt_threshold: 8
58    });
59  }
60
61  // Push-to-Talk: Call this when user holds the button
62  async startTalking() {
63    if (this.isRecording) return;
64    this.isRecording = true;
65
66    // Interrupt any current AI speech
67    this.socket.emit('control', { action: 'interrupt' });
68
69    try {
70      const stream = await navigator.mediaDevices.getUserMedia({ 
71        audio: {
72          sampleRate: 16000,
73          channelCount: 1,
74          echoCancellation: true,
75          noiseSuppression: true,
76          autoGainControl: true
77        }
78      });
79
80      this.mediaRecorder = new MediaRecorder(stream);
81      
82      this.mediaRecorder.ondataavailable = (event) => {
83        if (event.data.size > 0 && this.socket) {
84          const reader = new FileReader();
85          reader.onload = () => {
86            const audioData = reader.result.split(',')[1];
87            this.socket.emit('audio_chunk', {
88              audio: audioData,
89              format: 'pcm16',
90              sample_rate: 16000
91            });
92          };
93          reader.readAsDataURL(event.data);
94        }
95      };
96
97      // Send chunks every 100ms
98      this.mediaRecorder.start(100);
99      console.log('Listening...');
100
101    } catch (err) {
102      console.error('Error accessing microphone:', err);
103      this.isRecording = false;
104    }
105  }
106
107  // Push-to-Talk: Call this when user releases the button
108  stopTalking() {
109    if (!this.isRecording || !this.mediaRecorder) return;
110    
111    this.mediaRecorder.stop();
112    this.mediaRecorder.stream.getTracks().forEach(track => track.stop());
113    this.mediaRecorder = null;
114    this.isRecording = false;
115    
116    // Optional: Send a signal that speaking is done if needed by your logic,
117    // though the server typically handles VAD or end of stream.
118    console.log('Stopped listening');
119  }
120
121  playAudioChunk(base64Audio) {
122    const audioData = atob(base64Audio);
123    const audioArray = new Uint8Array(audioData.length);
124    for (let i = 0; i < audioData.length; i++) {
125      audioArray[i] = audioData.charCodeAt(i);
126    }
127    
128    const blob = new Blob([audioArray], { type: 'audio/mp3' });
129    const url = URL.createObjectURL(blob);
130    const audio = new Audio(url);
131    audio.play().catch(e => console.error('Playback failed:', e));
132  }
133
134  disconnect() {
135    if (this.socket) {
136      this.socket.disconnect();
137    }
138  }
139}
140
141// Usage Example (React/HTML)
142/*
143const agent = new VoiceAgent('your-api-key');
144agent.connect();
145
146// Bind to a button
147<button 
148  onMouseDown={() => agent.startTalking()}
149  onMouseUp={() => agent.stopTalking()}
150  onMouseLeave={() => agent.stopTalking()}
151>
152  Hold to Speak
153</button>
154*/