intellema-vdk 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

intellema_vdk/livekit_lib/client.py

@@ -1,280 +0,0 @@
-import os
-import json
-import uuid
-import asyncio
-import time
-import boto3
-from typing import List, Optional
-from dotenv import load_dotenv
-from livekit import api
-
-# Load environment variables
-load_dotenv(dotenv_path=".env.local")
-load_dotenv()
-
-class LiveKitManager:
-    def __init__(self):
-        self.url = os.getenv("LIVEKIT_URL")
-        self.api_key = os.getenv("LIVEKIT_API_KEY")
-        self.api_secret = os.getenv("LIVEKIT_API_SECRET")
-        self.sip_trunk_id = os.getenv("SIP_OUTBOUND_TRUNK_ID")
-
-        if not self.url or not self.api_key or not self.api_secret:
-            raise ValueError("LIVEKIT_URL, LIVEKIT_API_KEY, and LIVEKIT_API_SECRET must be set.")
-
-        self.lk_api = api.LiveKitAPI(
-            url=self.url,
-            api_key=self.api_key,
-            api_secret=self.api_secret,
-        )
-
-    async def close(self):
-        await self.lk_api.aclose()
-
-    async def start_outbound_call(self, phone_number: str, prompt_content: str, call_id: str = None, timeout: int = 600):
-        if not call_id:
-            call_id = f"outbound_call_{uuid.uuid4().hex[:12]}"
-
-        metadata = json.dumps({
-            "phone_number": phone_number,
-            "prompt_content": prompt_content
-        })
-
-        # 1. Create room with metadata
-        room = await self.lk_api.room.create_room(
-            api.CreateRoomRequest(
-                name=call_id,
-                empty_timeout=timeout,
-                metadata=metadata
-            )
-        )
-
-        # 2. Dispatch agent
-        await self.lk_api.agent_dispatch.create_dispatch(
-            api.CreateAgentDispatchRequest(
-                room=call_id,
-                agent_name="outbound-caller",
-                metadata=metadata
-            )
-        )
-
-        # 3. Initiate Outbound Call (SIP/PSTN)
-        if not self.sip_trunk_id:
-            raise ValueError("SIP_OUTBOUND_TRUNK_ID is not configured in environment.")
-
-        sip_participant_identity = f"phone-{phone_number}"
-
-        try:
-            await self.lk_api.sip.create_sip_participant(
-                api.CreateSIPParticipantRequest(
-                    room_name=call_id,
-                    sip_trunk_id=self.sip_trunk_id,
-                    sip_call_to=phone_number,
-                    participant_identity=sip_participant_identity,
-                    wait_until_answered=True,
-                )
-            )
-        except Exception as e:
-            # Handle SIP Busy/Error 
-            if "Busy Here" in str(e) or "486" in str(e):
-                print(f"Call failed: User is busy ({phone_number})")
-                # We might want to clean up the room if the call failed
-                await self.delete_room(call_id)
-                raise ValueError("User is busy")
-            raise e
-
-        return room
-
-    async def create_token(self, call_id: str, participant_name: str) -> str:
-        token = api.AccessToken(self.api_key, self.api_secret)
-        token.with_identity(participant_name)
-        token.with_name(participant_name)
-        token.with_grants(api.VideoGrants(
-            room_join=True,
-            room=call_id,
-        ))
-        return token.to_jwt()
-
-    async def delete_room(self, call_id: str):
-        await self.lk_api.room.delete_room(api.DeleteRoomRequest(room=call_id))
-
-    async def start_stream(self, call_id: str, rtmp_urls: List[str]):
-        await self.lk_api.egress.start_room_composite_egress(
-            api.RoomCompositeEgressRequest(
-                room_name=call_id,
-                layout="speaker",
-                stream_outputs=[
-                    api.StreamOutput(
-                        protocol=api.StreamProtocol.RTMP,
-                        urls=rtmp_urls
-                    )
-                ]
-            )
-        )
-
-    async def start_recording(self, call_id: str, output_filepath: Optional[str] = None, upload_to_s3: bool = True, wait_for_completion: bool = True):
-        """
-        Start recording a room.
-        
-        Args:
-            call_id: Name of the room/call to record.
-            output_filepath: Optional path/filename for the recording.
-            upload_to_s3: If True, uploads to S3 (requires env vars). If False, saves locally on Egress server.
-            wait_for_completion: If True, waits for the recording to finish and downloads it locally (if upload_to_s3 is True).
-        """
-        file_output = None
-        filename = output_filepath if output_filepath else f"{call_id}-{uuid.uuid4().hex[:6]}.mp4"
-
-        if upload_to_s3:
-            access_key = os.getenv("AWS_ACCESS_KEY_ID")
-            secret_key = os.getenv("AWS_SECRET_ACCESS_KEY")
-            bucket = os.getenv("AWS_S3_BUCKET")
-            region = os.getenv("AWS_REGION")
-            
-            if not access_key or not secret_key or not bucket:
-                raise ValueError("AWS credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_S3_BUCKET) are required for S3 upload.")
-            
-            file_output = api.EncodedFileOutput(
-                file_type=api.EncodedFileType.MP4,
-                filepath=filename,
-                s3=api.S3Upload(
-                    access_key=access_key,
-                    secret=secret_key,
-                    bucket=bucket,
-                    region=region,
-                ),
-            )
-            print(f"Starting recording. File will be saved to S3: s3://{bucket}/{filename}")
-        else:
-            file_output = api.EncodedFileOutput(
-                file_type=api.EncodedFileType.MP4,
-                filepath=filename,
-            )
-            print(f"Starting recording. File will be saved locally: {filename}")
-        
-        egress_info = await self.lk_api.egress.start_room_composite_egress(
-            api.RoomCompositeEgressRequest(
-                room_name=call_id,
-                layout="grid",
-                preset=api.EncodingOptionsPreset.H264_720P_30,
-                file_outputs=[file_output]
-            )
-        )
-
-        if wait_for_completion and upload_to_s3:
-            egress_id = egress_info.egress_id
-            print(f"Waiting for egress {egress_id} to complete...")
-            
-            while True:
-                try:
-                    egress_list = await self.lk_api.egress.list_egress(api.ListEgressRequest(egress_id=egress_id))
-                except Exception as e:
-                    print(f"Error checking egress status: {e}")
-                    await asyncio.sleep(5)
-                    continue
-
-                if not egress_list.items:
-                    print("Egress info not found during polling.")
-                    break
-                
-                info = egress_list.items[0]
-                if info.status == api.EgressStatus.EGRESS_COMPLETE:
-                    print("Egress completed successfully.")
-                    break
-                elif info.status == api.EgressStatus.EGRESS_FAILED:
-                    raise RuntimeError(f"Egress failed: {info.error}")
-                elif info.status == api.EgressStatus.EGRESS_LIMIT_REACHED:
-                     raise RuntimeError(f"Egress limit reached: {info.error}")
-                
-                await asyncio.sleep(5)
-
-            # Download from S3
-            print(f"Downloading {filename} from S3 bucket {bucket}...")
-            s3 = boto3.client(
-                's3',
-                aws_access_key_id=access_key,
-                aws_secret_access_key=secret_key,
-                region_name=region
-            )
-            
-            local_dir = "recordings"
-            os.makedirs(local_dir, exist_ok=True)
-            local_path = os.path.join(local_dir, filename)
-            
-            try:
-                s3.download_file(bucket, filename, local_path)
-                print(f"Recording downloaded to: {local_path}")
-            except Exception as e:
-                print(f"Failed to download recording: {e}")
-                raise e
-
-    async def kick_participant(self, call_id: str, identity: str):
-        await self.lk_api.room.remove_participant(
-            api.RoomParticipantIdentity(
-                room=call_id,
-                identity=identity
-            )
-        )
-
-    async def mute_participant(self, call_id: str, identity: str, track_sid: str, muted: bool):
-        await self.lk_api.room.mute_published_track(
-            api.MuteRoomTrackRequest(
-                room=call_id,
-                identity=identity,
-                track_sid=track_sid,
-                muted=muted
-            )
-        )
-
-    async def send_alert(self, call_id: str, message: str, participant_identity: Optional[str] = None):
-        destination_identities = [participant_identity] if participant_identity else []
-        data_packet = json.dumps({"type": "alert", "message": message}).encode('utf-8')
-
-        await self.lk_api.room.send_data(
-            api.SendDataRequest(
-                room=call_id,
-                data=data_packet,
-                kind=1,  # 1 = RELIABLE, 0 = LOSSY
-                destination_identities=destination_identities
-            )
-        )
-
-    async def get_participant_identities(self, call_id: str) -> List[dict]:
-        """
-        Get a list of all participants in a room with their identities and tracks.
-        
-        Returns:
-            List of dicts with participant info:
-            [
-                {
-                    "identity": str,
-                    "name": str,
-                    "tracks": [
-                        {"sid": str, "type": str, "muted": bool, "source": str},
-                        ...
-                    ]
-                },
-                ...
-            ]
-        """
-        response = await self.lk_api.room.list_participants(
-            api.ListParticipantsRequest(room=call_id)
-        )
-        participants = []
-        for p in response.participants:
-            tracks = []
-            for track in p.tracks:
-                tracks.append({
-                    "sid": track.sid,
-                    "type": "audio" if track.type == 1 else "video" if track.type == 2 else "unknown",
-                    "muted": track.muted,
-                    "source": track.source.name if hasattr(track.source, 'name') else str(track.source)
-                })
-            participants.append({
-                "identity": p.identity,
-                "name": p.name,
-                "tracks": tracks
-            })
-        return participants
-
-    

intellema_vdk/retell_lib/retell_client.py

@@ -1,248 +0,0 @@
-import os
-from typing import List, Optional
-from dotenv import load_dotenv
-from twilio.rest import Client
-from retell import Retell
-import time
-import uuid
-import requests
-import boto3
-
-# Load environment variables
-load_dotenv(dotenv_path=".env.local")
-load_dotenv()
-
-class RetellManager:
-    def __init__(self):
-        self.twilio_account_sid = os.getenv("TWILIO_ACCOUNT_SID")
-        self.twilio_auth_token = os.getenv("TWILIO_AUTH_TOKEN")
-        self.twilio_number = os.getenv("TWILIO_PHONE_NUMBER")
-        self.retell_api_key = os.getenv("RETELL_API_KEY")
-        self.retell_agent_id = os.getenv("RETELL_AGENT_ID")
-
-        if not all([self.twilio_account_sid, self.twilio_auth_token, self.twilio_number, self.retell_api_key, self.retell_agent_id]):
-            raise ValueError("Missing necessary environment variables for RetellManager")
-
-        self.twilio_client = Client(self.twilio_account_sid, self.twilio_auth_token)
-        self.retell_client = Retell(api_key=self.retell_api_key)
-
-    def import_phone_number(self, termination_uri: str = None, outbound_agent_id: str = None, inbound_agent_id: str = None, nickname: str = None, sip_trunk_auth_username: str = None, sip_trunk_auth_password: str = None):
-        """
-        Import/register your Twilio phone number with Retell.
-        This is required before you can make outbound calls using the phone number.
-        
-        Args:
-            termination_uri: Twilio SIP trunk termination URI (e.g., "yourtrunk.pstn.twilio.com").
-                           If not provided, will try to use a default format.
-            outbound_agent_id: Agent ID to use for outbound calls. Defaults to self.retell_agent_id.
-            inbound_agent_id: Agent ID to use for inbound calls. Defaults to None (no inbound).
-            nickname: Optional nickname for the phone number.
-            sip_trunk_auth_username: Username for SIP trunk authentication (if using credential list).
-            sip_trunk_auth_password: Password for SIP trunk authentication (if using credential list).
-        
-        Returns:
-            The phone number registration response from Retell.
-        """
-        # Build the import kwargs
-        import_kwargs = {
-            "phone_number": self.twilio_number,
-        }
-        
-        # Add termination URI if provided
-        if termination_uri:
-            import_kwargs["termination_uri"] = termination_uri
-        
-        # Add SIP credentials if provided
-        if sip_trunk_auth_username and sip_trunk_auth_password:
-            import_kwargs["sip_trunk_auth_username"] = sip_trunk_auth_username
-            import_kwargs["sip_trunk_auth_password"] = sip_trunk_auth_password
-        
-        # Set outbound agent (required for outbound calls)
-        if outbound_agent_id:
-            import_kwargs["outbound_agent_id"] = outbound_agent_id
-        elif self.retell_agent_id:
-            import_kwargs["outbound_agent_id"] = self.retell_agent_id
-        
-        # Set inbound agent if provided
-        if inbound_agent_id:
-            import_kwargs["inbound_agent_id"] = inbound_agent_id
-        
-        # Add nickname if provided
-        if nickname:
-            import_kwargs["nickname"] = nickname
-        
-        try:
-            response = self.retell_client.phone_number.import_(**import_kwargs)
-            print(f"✓ Phone number {self.twilio_number} successfully imported to Retell!")
-            print(f"  Phone Number: {response.phone_number}")
-            print(f"  Type: {response.phone_number_type}")
-            if hasattr(response, 'outbound_agent_id') and response.outbound_agent_id:
-                print(f"  Outbound Agent: {response.outbound_agent_id}")
-            if hasattr(response, 'inbound_agent_id') and response.inbound_agent_id:
-                print(f"  Inbound Agent: {response.inbound_agent_id}")
-            return response
-        except Exception as e:
-            print(f"✗ Error importing phone number: {e}")
-            print(f"\nNote: If you're using Twilio, you may need to:")
-            print(f"  1. Create an Elastic SIP Trunk in Twilio console")
-            print(f"  2. Provide the termination_uri parameter (e.g., 'yourtrunk.pstn.twilio.com')")
-            print(f"  3. Or purchase the number directly through Retell dashboard")
-            raise
-
-
-    def start_outbound_call(self, phone_number: str, prompt_content: str = None, call_id: str = None) -> str:
-        call_kwargs = {
-            "from_number": self.twilio_number,
-            "to_number": phone_number,
-            "override_agent_id": self.retell_agent_id,
-        }
-    
-        if call_id:
-            call_kwargs["metadata"] = {"call_id": call_id}
-    
-    # Only set up dynamic variables if we have a custom prompt
-        if prompt_content:
-            enhanced_prompt = (
-                f"{prompt_content}\n\n"
-                "SYSTEM INSTRUCTION: Continually check the dynamic variable {{force_end}}. "
-                "If {{force_end}} == 'true, you must IMMEDIATELY say goodbye and activate your end_call tool to terminate the call."
-            )
-            call_kwargs["retell_llm_dynamic_variables"] = {
-                "prompt_content": enhanced_prompt,
-                "force_end": "false"
-            }
-    
-        call_response = self.retell_client.call.create_phone_call(**call_kwargs)
-    
-        print(f"Call created successfully!")
-        print(f"Retell Call ID: {call_response.call_id}")
-        print(f"Call Status: {call_response.call_status}")
-    
-        return call_response.call_id
-
-    def delete_room(self, call_id: str):
-        try:
-            call_data = self.retell_client.call.retrieve(call_id)
-            print(f"Current call status: {call_data.call_status}")
-
-            if call_data.call_status in ['registered', 'ongoing', 'dialing']:
-                print(f"Triggering end for Retell call {call_id}...")
-
-                self.retell_client.call.update(
-                    call_id,
-                    override_dynamic_variables={"force_end": "true"}
-                )
-
-                print("✓ force_end override sent to Retell API")
-            else:
-                print(f"Call already ended: {call_data.call_status}")
-
-        except Exception as e:
-            print(f"Error ending call {call_id}: {e}")
-            raise
-
-    def start_stream(self, call_id: str, rtmp_urls: List[str]):
-        """
-        Starts a Twilio Media Stream.
-        Note: Twilio streams are WebSocket-based. If rtmp_urls contains a WSS URL, it will work.
-        """
-        if not rtmp_urls:
-            raise ValueError("No stream URLs provided")
-            
-        self.twilio_client.calls(call_id).streams.create(
-            url=rtmp_urls[0]
-        )
-
-    def start_recording(self, call_id: str, output_filepath: Optional[str] = None, upload_to_s3: bool = True, wait_for_completion: bool = True):
-        """
-        Triggers a recording on the active Twilio call.
-        
-        Args:
-            call_id: The Twilio Call SID.
-            output_filepath: Optional filename for the recording.
-            upload_to_s3: If True, uploads to S3.
-            wait_for_completion: If True, waits for recording to finish and then uploads.
-        
-        Returns:
-            The Twilio Recording SID.
-        """
-        
-        # Start Twilio recording
-        recording = self.twilio_client.calls(call_id).recordings.create()
-        print(f"Recording started: {recording.sid}")
-        
-        if not wait_for_completion:
-            return recording.sid
-        
-        # Poll for recording completion
-        print("Waiting for recording to complete...")
-        while True:
-            rec_status = self.twilio_client.recordings(recording.sid).fetch()
-            if rec_status.status == 'completed':
-                print("Recording completed.")
-                break
-            elif rec_status.status in ['failed', 'absent']:
-                raise RuntimeError(f"Recording failed with status: {rec_status.status}")
-            time.sleep(5)
-        
-        if not upload_to_s3:
-            return recording.sid
-        
-        # Download recording from Twilio
-        media_url = f"https://api.twilio.com/2010-04-01/Accounts/{self.twilio_account_sid}/Recordings/{recording.sid}.mp3"
-        print(f"Downloading recording from: {media_url}")
-        
-        response = requests.get(media_url, auth=(self.twilio_account_sid, self.twilio_auth_token))
-        if response.status_code != 200:
-            raise RuntimeError(f"Failed to download recording: {response.status_code} {response.text}")
-        
-        # Upload to S3
-        access_key = os.getenv("AWS_ACCESS_KEY_ID")
-        secret_key = os.getenv("AWS_SECRET_ACCESS_KEY")
-        bucket = os.getenv("AWS_S3_BUCKET")
-        region = os.getenv("AWS_REGION")
-        
-        if not access_key or not secret_key or not bucket:
-            raise ValueError("AWS credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_S3_BUCKET) are required for S3 upload.")
-        
-        filename = output_filepath if output_filepath else f"{call_id}-{uuid.uuid4().hex[:6]}.mp3"
-        
-        s3 = boto3.client(
-            's3',
-            aws_access_key_id=access_key,
-            aws_secret_access_key=secret_key,
-            region_name=region
-        )
-        
-        print(f"Uploading to S3: s3://{bucket}/{filename}")
-        s3.put_object(Bucket=bucket, Key=filename, Body=response.content)
-        print(f"Upload complete: s3://{bucket}/{filename}")
-        
-        # Also save locally
-        local_dir = "recordings"
-        os.makedirs(local_dir, exist_ok=True)
-        local_path = os.path.join(local_dir, filename)
-        with open(local_path, 'wb') as f:
-            f.write(response.content)
-        print(f"Recording saved locally: {local_path}")
-        
-        return recording.sid
-
-    def mute_participant(self, call_id: str, identity: str, track_sid: str, muted: bool):
-        """
-        Mutes the participant on the Twilio call.
-        This prevents audio from reaching the Retell AI.
-        """
-        self.twilio_client.calls(call_id).update(muted=muted)
-
-    def kick_participant(self, call_id: str, identity: str):
-        """
-        Alias for delete_room (hangup).
-        """
-        self.delete_room(call_id)
-
-    def send_alert(self, call_id: str, message: str, participant_identity: Optional[str] = None):
-        """
-        Not fully supported in this hybrid model
-        """
-        raise NotImplementedError("send_alert is not currently supported in RetellManager")

intellema_vdk/speech_lib/__init__.py

@@ -1,2 +0,0 @@
-from .stt_client import STTManager
-from .tts_streamer import TTSStreamer

intellema_vdk/speech_lib/stt_client.py

@@ -1,108 +0,0 @@
-import os
-import logging
-import httpx
-from dotenv import load_dotenv
-from openai import AsyncOpenAI
-
-load_dotenv()
-logger = logging.getLogger(__name__)
-
-
-class STTManager:
-    def __init__(self):
-        """
-        Initializes the STTManager.
-        
-        Note:
-            The following must be set in your .env file:
-            - OPENAI_API_KEY
-            - AGENT_API_URL (If not set, posting to agent will be disabled)
-        """
-        self._api_key = os.getenv("OPENAI_API_KEY")
-        if not self._api_key:
-            raise ValueError("OPENAI_API_KEY must be set in your .env file.")
-        
-        self._agent_api_url = os.getenv("AGENT_API_URL")
-        if not self._agent_api_url:
-            logger.warning("AGENT_API_URL is not set in .env. Posting to agent will be disabled.")
-        
-        self._openai_client = AsyncOpenAI(api_key=self._api_key)
-        self._http_client = httpx.AsyncClient()
-
-    async def close(self):
-        """
-        Cleans up resources used by the STTManager.
-        """
-        await self._http_client.aclose()
-        await self._openai_client.close()
-
-    async def transcribe_audio(self, file_path: str, model: str = "whisper-1") -> str:
-        """
-        Transcribes an audio file using OpenAI's whisper model.
-
-        Args:
-            file_path: The path to the audio file to transcribe. 
-                       Supported formats: mp3, mp4, mpeg, mpga, m4a, wav, and webm.
-            model: The name of the whisper model to use.
-                   Note: The OpenAI API currently only supports "whisper-1".
-        Returns:
-            The transcribed text as a string.
-        """
-        logger.info(f"Starting transcription for file: {file_path}")
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"Audio file not found at: {file_path}")
-
-        with open(file_path, "rb") as audio_file:
-            transcript = await self._openai_client.audio.transcriptions.create(
-                model=model,
-                file=audio_file
-            )
-        logger.info(f"Successfully transcribed file: {file_path}")
-
-        return transcript.text
-
-    async def transcribe_and_post(self, file_path: str):
-        """
-        Processes an audio file by transcribing it and posting the result to the agent API under a 'message' key.
-
-        Args:
-            file_path: The path to the audio file to process.
-                       Supported formats: mp3, mp4, mpeg, mpga, m4a, wav, and webm.
-        Returns:
-            The transcribed text as a string.
-        """
-        try:
-            # Transcribe the audio file
-            transcript_text = await self.transcribe_audio(file_path)
-
-            # Post the transcribed text to the agent API
-            if self._agent_api_url:
-                await self._post_to_agent(transcript_text)
-            else:
-                logger.info("AGENT_API_URL not set, skipping post to agent.")
-            
-            return transcript_text
-
-        except FileNotFoundError:
-            logger.error(f"Audio file not found at: {file_path}", exc_info=True)
-            raise
-        except Exception as e:
-            logger.error(f"An error occurred during processing of {file_path}: {e}", exc_info=True)
-            raise
-
-    async def _post_to_agent(self, text: str):
-        """
-        Posts the transcribed text to the agent API under a 'message' key.
-        
-        Args:
-            text: The transcribed text to post.
-        """
-        payload = {"message": text}
-        try:
-            logger.info(f"Posting to agent with payload: {payload}")
-            response = await self._http_client.post(self._agent_api_url, json=payload)
-            response.raise_for_status()
-            logger.info(f"Successfully posted to agent. Status: {response.status_code}")
-        except httpx.HTTPError as e:
-            logger.error(f"Failed to post to agent API: {e}", exc_info=True)
-            raise