1├── agent/
2│   ├── ai_agent.py           # Core AI translation agent
3│   └── audio_stream_track.py # Custom audio processing
4├── intelligence/
5│   └── openai/
6│       └── openai_intelligence.py  # OpenAI API integration
7├── client/                   # Frontend application
8└── README.md                 # Project documentation
9

1def __init__(self, meeting_id: str, authToken: str, name: str):
2    self.loop = asyncio.get_event_loop()
3    self.audio_track = CustomAudioStreamTrack(
4        loop=self.loop,
5        handle_interruption=True
6    )
7    self.meeting_config = MeetingConfig(
8        name=name,
9        meeting_id=meeting_id,
10        token=authToken,
11        mic_enabled=True,
12        webcam_enabled=False,
13        custom_microphone_audio_track=self.audio_track
14    )
15    # Initialize OpenAI connection parameters
16    self.intelligence = OpenAIIntelligence(
17        loop=self.loop,
18        api_key=api_key,
19        base_url="api.openai.com",
20        input_audio_transcription=InputAudioTranscription(model="whisper-1"),
21        audio_track=self.audio_track
22    )
23    
24    self.participants_data = {}
25

1def on_participant_joined(self, participant: Participant):
2    peer_name = participant.display_name
3    native_lang = participant.meta_data["preferredLanguage"]
4    self.participants_data[participant.id] = {
5        "name": peer_name,
6        "lang": native_lang
7    }
8    
9    if len(self.participants_data) == 2:
10        # Extract the info for each participant
11        participant_ids = list(self.participants_data.keys())
12        p1 = self.participants_data[participant_ids[0]]
13        p2 = self.participants_data[participant_ids[1]]
14
15        # Build translator-specific instructions
16        translator_instructions = f"""
17            You are a real-time translator bridging a conversation between:
18            - {p1['name']} (speaks {p1['lang']})
19            - {p2['name']} (speaks {p2['lang']})
20
21            You have to listen and speak those exactly word in different language
22            eg. when {p1['lang']} is spoken then say that exact in language {p2['lang']}
23            similar when {p2['lang']} is spoken then say that exact in language {p1['lang']}
24            Keep in account who speaks what and use 
25            NOTE - 
26            Your job is to translate, from one language to another, don't engage in any conversation
27        """
28
29        # Update OpenAI's instructions
30        asyncio.create_task(self.intelligence.update_session_instructions(translator_instructions))
31

1async def add_audio_listener(self, stream: Stream):
2    while True:
3        try:
4            await asyncio.sleep(0.01)
5            if not self.intelligence.ws:
6                continue
7
8            frame = await stream.track.recv()      
9            audio_data = frame.to_ndarray()[0]
10            audio_data_float = (
11                audio_data.astype(np.float32) / np.iinfo(np.int16).max
12            )
13            audio_mono = librosa.to_mono(audio_data_float.T)
14            audio_resampled = librosa.resample(
15                audio_mono, orig_sr=48000, target_sr=16000
16            )
17            pcm_frame = (
18                (audio_resampled * np.iinfo(np.int16).max)
19                .astype(np.int16)
20                .tobytes()
21            )
22            
23            # Send to OpenAI
24            await self.intelligence.send_audio_data(pcm_frame)
25
26        except Exception as e:
27            print("Audio processing error:", e)
28            break
29

1async def add_new_bytes(self, audio_data_stream: Iterator[bytes]):
2    await self._process_audio_task_queue.put(audio_data_stream)
3

1async def connect(self):
2    url = f"wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview"
3    logger.info("Establishing OpenAI WS connection... ")
4    self.ws = await self._http_session.ws_connect(
5        url=url,
6        headers={
7            "Authorization": f"Bearer {self.api_key}",
8            "OpenAI-Beta": "realtime=v1",
9        },
10    )
11    
12    if self.pending_instructions is not None:
13        await self.update_session_instructions(self.pending_instructions)
14
15    logger.info("OpenAI WS connection established")
16    self.receive_message_task = self.loop.create_task(
17        self.receive_message_handler()
18    )
19
20    await self.update_session(self.session_update_params)
21    await self.receive_message_task
22

1def handle_response(self, message: str):
2    message = json.loads(message)
3
4    match message["type"]:
5        case EventType.SESSION_CREATED:
6            logger.info(f"Server Message: {message["type"]}")
7            
8        case EventType.SESSION_UPDATE:
9            logger.info(f"Server Message: {message["type"]}")
10
11        case EventType.RESPONSE_AUDIO_DELTA:
12            logger.info(f"Server Message: {message["type"]}")
13            self.on_audio_response(base64.b64decode(message["delta"]))
14            
15        case EventType.RESPONSE_AUDIO_TRANSCRIPT_DONE:
16            logger.info(f"Server Message: {message["type"]}")
17            print(f"Response Transcription: {message["transcript"]}")
18        
19        case EventType.ITEM_INPUT_AUDIO_TRANSCRIPTION_COMPLETED:
20            logger.info(f"Server Message: {message["type"]}")
21            print(f"Client Transcription: {message["transcript"]}")
22