livellm 1.2.0__py3-none-any.whl → 1.3.5__py3-none-any.whl

livellm/__init__.py

@@ -1,15 +1,19 @@
 """LiveLLM Client - Python client for the LiveLLM Proxy and Realtime APIs."""
 
-from .livellm import LivellmClient
+from .livellm import LivellmClient, LivellmWsClient, BaseLivellmClient
+from .transcripton import TranscriptionWsClient
 from . import models
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 __all__ = [    
     # Version
     "__version__",
     # Classes
     "LivellmClient",
+    "LivellmWsClient",
+    "BaseLivellmClient",
+    "TranscriptionWsClient",
     # Models
     *models.__all__,
 ]

livellm/livellm.py

@@ -6,205 +6,17 @@ import warnings
 from typing import List, Optional, AsyncIterator, Union, overload
 from .models.common import Settings, SuccessResponse
 from .models.agent.agent import AgentRequest, AgentResponse
-from .models.audio.speak import SpeakRequest
+from .models.audio.speak import SpeakRequest, EncodedSpeakResponse
 from .models.audio.transcribe import TranscribeRequest, TranscribeResponse, File
 from .models.fallback import AgentFallbackRequest, AudioFallbackRequest, TranscribeFallbackRequest
+import websockets
+from .models.ws import WsRequest, WsResponse, WsStatus, WsAction
+from .transcripton import TranscriptionWsClient
+from abc import ABC, abstractmethod
 
-class LivellmClient:
 
-    def __init__(
-        self, 
-        base_url: str, 
-        timeout: Optional[float] = None,
-        configs: Optional[List[Settings]] = None
-        ):
-        base_url = base_url.rstrip("/")
-        self.base_url = f"{base_url}/livellm"
-        self.timeout = timeout
-        self.client = httpx.AsyncClient(base_url=self.base_url, timeout=self.timeout) \
-            if self.timeout else httpx.AsyncClient(base_url=self.base_url)
-        self.settings = []
-        self.headers = {
-            "Content-Type": "application/json",
-        }
-        if configs:
-            self.update_configs_post_init(configs)
-    
-
-    def update_configs_post_init(self, configs: List[Settings]) -> SuccessResponse:
-        """
-        Update the configs after the client is initialized.
-        Args:
-            configs: The configs to update.
-        """
-        with httpx.Client(base_url=self.base_url, timeout=self.timeout) as client:
-            for config in configs:
-                response = client.post(f"{self.base_url}/providers/config", json=config.model_dump())
-                response.raise_for_status()
-                self.settings.append(config)
-            return SuccessResponse(success=True, message="Configs updated successfully")
-        
-
-    async def delete(self, endpoint: str) -> dict:
-        """
-        Delete a resource from the given endpoint and return the response.
-        Args:
-            endpoint: The endpoint to delete from.
-        Returns:
-            The response from the endpoint.
-        """
-        response = await self.client.delete(endpoint, headers=self.headers)
-        response.raise_for_status()
-        return response.json()
-    
-    async def post_multipart(
-        self,
-        files: dict,
-        data: dict,
-        endpoint: str
-    ) -> dict:
-        """
-        Post a multipart request to the given endpoint and return the response.
-        Args:
-            files: The files to send in the request.
-            data: The data to send in the request.
-            endpoint: The endpoint to post to.
-        Returns:
-            The response from the endpoint.
-        """
-        # Don't pass Content-Type header for multipart - httpx will set it automatically
-        response = await self.client.post(endpoint, files=files, data=data)
-        response.raise_for_status()
-        return response.json()
-    
-    
-    async def get(
-        self,
-        endpoint: str
-    ) -> dict:
-        """
-        Get a request from the given endpoint and return the response.
-        Args:
-            endpoint: The endpoint to get from.
-        Returns:
-            The response from the endpoint.
-        """
-        response = await self.client.get(endpoint, headers=self.headers)
-        response.raise_for_status()
-        return response.json()
-    
-    async def post(
-        self, 
-        json_data: dict, 
-        endpoint: str, 
-        expect_stream: bool = False, 
-        expect_json: bool = True
-    ) -> Union[dict, bytes, AsyncIterator[Union[dict, bytes]]]:
-        """
-        Post a request to the given endpoint and return the response.
-        If expect_stream is True, return an AsyncIterator of the response.
-        If expect_json is True, return the response as a JSON object.
-        Otherwise, return the response as bytes.
-        Args:
-            json_data: The JSON data to send in the request.
-            endpoint: The endpoint to post to.
-            expect_stream: Whether to expect a stream response.
-            expect_json: Whether to expect a JSON response.
-        Returns:
-            The response from the endpoint.
-        Raises:
-            Exception: If the response is not 200 or 201.
-        """
-        response = await self.client.post(endpoint, json=json_data, headers=self.headers)
-        if response.status_code not in [200, 201]:
-            error_response = await response.aread()
-            error_response = error_response.decode("utf-8")
-            raise Exception(f"Failed to post to {endpoint}: {error_response}")
-        if expect_stream:
-            async def json_stream_response() -> AsyncIterator[dict]:
-                async for chunk in response.aiter_lines():
-                    chunk = chunk.strip()
-                    if not chunk:
-                        continue
-                    yield json.loads(chunk)
-            async def bytes_stream_response() -> AsyncIterator[bytes]:
-                async for chunk in response.aiter_bytes():
-                    yield chunk
-            stream_response = json_stream_response if expect_json else bytes_stream_response
-            return stream_response()
-        else:
-            if expect_json:
-                return response.json()
-            else:
-                return response.content
 
-    
-    async def ping(self) -> SuccessResponse:
-        result = await self.get("ping")
-        return SuccessResponse(**result)
-    
-    async def update_config(self, config: Settings) -> SuccessResponse:
-        result = await self.post(config.model_dump(), "providers/config", expect_json=True)
-        self.settings.append(config)
-        return SuccessResponse(**result)
-    
-    async def update_configs(self, configs: List[Settings]) -> SuccessResponse:
-        for config in configs:
-            await self.update_config(config)
-        return SuccessResponse(success=True, message="Configs updated successfully")
-    
-    async def get_configs(self) -> List[Settings]:
-        result = await self.get("providers/configs")
-        return [Settings(**config) for config in result]
-    
-    async def delete_config(self, config_uid: str) -> SuccessResponse:
-        result = await self.delete(f"providers/config/{config_uid}")
-        return SuccessResponse(**result)
-    
-    async def cleanup(self):
-        """
-        Delete all the created settings resources and close the client.
-        Should be called when you're done using the client.
-        """
-        for config in self.settings:
-            config: Settings = config
-            await self.delete_config(config.uid)
-        await self.client.aclose()
-    
-    async def __aenter__(self):
-        """Async context manager entry."""
-        return self
-    
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
-        await self.cleanup()
-    
-    def __del__(self):
-        """
-        Destructor to clean up resources when the client is garbage collected.
-        This will close the HTTP client and attempt to delete configs if cleanup wasn't called.
-        Note: It's recommended to use the async context manager or call cleanup() explicitly.
-        """
-        # Warn user if cleanup wasn't called
-        if self.settings:
-            warnings.warn(
-                "LivellmClient is being garbage collected without explicit cleanup. "
-                "Provider configs may not be deleted from the server. "
-                "Consider using 'async with' or calling 'await client.cleanup()' explicitly.",
-                ResourceWarning,
-                stacklevel=2
-            )
-        
-        # Close the httpx client synchronously
-        # httpx.AsyncClient stores a sync Transport that needs cleanup
-        try:
-            with httpx.Client(base_url=self.base_url) as client:
-                for config in self.settings:
-                    config: Settings = config
-                    client.delete("providers/config/{config.uid}", headers=self.headers)
-        except Exception:
-            # Silently fail - we're in a destructor
-            pass
+class BaseLivellmClient(ABC):
 
     @overload
     async def agent_run(
@@ -225,6 +37,11 @@ class LivellmClient:
     ) -> AgentResponse:
         ...
     
+    
+    @abstractmethod
+    async def handle_agent_run(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AgentResponse:
+        ...
+    
     async def agent_run(
         self,
         request: Optional[Union[AgentRequest, AgentFallbackRequest]] = None,
@@ -269,9 +86,8 @@ class LivellmClient:
                 raise TypeError(
                     f"First positional argument must be AgentRequest or AgentFallbackRequest, got {type(request)}"
                 )
-            result = await self.post(request.model_dump(), "agent/run", expect_json=True)
-            return AgentResponse(**result)
-        
+            return await self.handle_agent_run(request)
+    
         # Otherwise, use keyword arguments
         if provider_uid is None or model is None or messages is None:
             raise ValueError(
@@ -286,8 +102,7 @@ class LivellmClient:
             tools=tools or [],
             gen_config=kwargs or None
         )
-        result = await self.post(agent_request.model_dump(), "agent/run", expect_json=True)
-        return AgentResponse(**result)
+        return await self.handle_agent_run(agent_request)
     
     @overload
     def agent_run_stream(
@@ -308,6 +123,11 @@ class LivellmClient:
     ) -> AsyncIterator[AgentResponse]:
         ...
     
+    
+    @abstractmethod
+    async def handle_agent_run_stream(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AsyncIterator[AgentResponse]:
+        ...
+    
     async def agent_run_stream(
         self,
         request: Optional[Union[AgentRequest, AgentFallbackRequest]] = None,
@@ -355,9 +175,7 @@ class LivellmClient:
                 raise TypeError(
                     f"First positional argument must be AgentRequest or AgentFallbackRequest, got {type(request)}"
                 )
-            stream = await self.post(request.model_dump(), "agent/run_stream", expect_stream=True, expect_json=True)
-            async for chunk in stream:
-                yield AgentResponse(**chunk)
+            stream = self.handle_agent_run_stream(request)
         else:
             # Otherwise, use keyword arguments
             if provider_uid is None or model is None or messages is None:
@@ -373,9 +191,10 @@ class LivellmClient:
                 tools=tools or [],
                 gen_config=kwargs or None
             )
-            stream = await self.post(agent_request.model_dump(), "agent/run_stream", expect_stream=True, expect_json=True)
-            async for chunk in stream:
-                yield AgentResponse(**chunk)
+            stream = self.handle_agent_run_stream(agent_request)
+        
+        async for chunk in stream:
+            yield chunk
     
     @overload
     async def speak(
@@ -399,6 +218,11 @@ class LivellmClient:
     ) -> bytes:
         ...
     
+    
+    @abstractmethod
+    async def handle_speak(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> bytes:
+        ...
+    
     async def speak(
         self,
         request: Optional[Union[SpeakRequest, AudioFallbackRequest]] = None,
@@ -451,7 +275,7 @@ class LivellmClient:
                 raise TypeError(
                     f"First positional argument must be SpeakRequest or AudioFallbackRequest, got {type(request)}"
                 )
-            return await self.post(request.model_dump(), "audio/speak", expect_json=False)
+            return await self.handle_speak(request)
         
         # Otherwise, use keyword arguments
         if provider_uid is None or model is None or text is None or voice is None or mime_type is None or sample_rate is None:
@@ -470,7 +294,7 @@ class LivellmClient:
             chunk_size=chunk_size,
             gen_config=kwargs or None
         )
-        return await self.post(speak_request.model_dump(), "audio/speak", expect_json=False)
+        return await self.handle_speak(speak_request)
     
     @overload
     def speak_stream(
@@ -494,6 +318,11 @@ class LivellmClient:
     ) -> AsyncIterator[bytes]:
         ...
     
+    
+    @abstractmethod
+    async def handle_speak_stream(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> AsyncIterator[bytes]:
+        ...
+    
     async def speak_stream(
         self,
         request: Optional[Union[SpeakRequest, AudioFallbackRequest]] = None,
@@ -549,9 +378,7 @@ class LivellmClient:
                 raise TypeError(
                     f"First positional argument must be SpeakRequest or AudioFallbackRequest, got {type(request)}"
                 )
-            speak_stream = await self.post(request.model_dump(), "audio/speak_stream", expect_stream=True, expect_json=False)
-            async for chunk in speak_stream:
-                yield chunk
+            speak_stream = self.handle_speak_stream(request)
         else:
             # Otherwise, use keyword arguments
             if provider_uid is None or model is None or text is None or voice is None or mime_type is None or sample_rate is None:
@@ -570,9 +397,9 @@ class LivellmClient:
                 chunk_size=chunk_size,
                 gen_config=kwargs or None
             )
-            speak_stream = await self.post(speak_request.model_dump(), "audio/speak_stream", expect_stream=True, expect_json=False)
-            async for chunk in speak_stream:
-                yield chunk
+            speak_stream = self.handle_speak_stream(speak_request)
+        async for chunk in speak_stream:
+            yield chunk
     
     @overload
     async def transcribe(
@@ -593,6 +420,11 @@ class LivellmClient:
     ) -> TranscribeResponse:
         ...
         
+    
+    @abstractmethod
+    async def handle_transcribe(self, request: Union[TranscribeRequest, TranscribeFallbackRequest]) -> TranscribeResponse:
+        ...
+    
     async def transcribe(
         self,
         request: Optional[Union[TranscribeRequest, TranscribeFallbackRequest]] = None,
@@ -636,9 +468,8 @@ class LivellmClient:
                     f"First positional argument must be TranscribeRequest or TranscribeFallbackRequest, got {type(request)}"
                 )
             # JSON-based request
-            result = await self.post(request.model_dump(), "audio/transcribe_json", expect_json=True)
-            return TranscribeResponse(**result)
-        
+            return await self.handle_transcribe(request)
+            
         # Otherwise, use keyword arguments with multipart form-data request
         if provider_uid is None or file is None or model is None:
             raise ValueError(
@@ -646,18 +477,394 @@ class LivellmClient:
                 "Alternatively, pass a TranscribeRequest object as the first positional argument."
             )
         
-        files = {
-            "file": file
-        }
-        data = {
-            "provider_uid": provider_uid,
-            "model": model,
-            "language": language,
-            "gen_config": json.dumps(kwargs) if kwargs else None
+        transcribe_request = TranscribeRequest(
+            provider_uid=provider_uid,
+            file=file,
+            model=model,
+            language=language,
+            gen_config=kwargs or None
+        )
+        return await self.handle_transcribe(transcribe_request)
+
+
+class LivellmWsClient(BaseLivellmClient):
+    """WebSocket-based LiveLLM client for real-time bidirectional communication."""
+
+    def __init__(
+        self, 
+        base_url: str, 
+        timeout: Optional[float] = None,
+        max_size: Optional[int] = None
+    ):
+        # Convert HTTP(S) URL to WS(S) URL
+        base_url = base_url.rstrip("/")
+        if base_url.startswith("https://"):
+            ws_url = base_url.replace("https://", "wss://")
+        elif base_url.startswith("http://"):
+            ws_url = base_url.replace("http://", "ws://")
+        else:
+            ws_url = base_url
+
+        # Root WebSocket base URL (without path) and main /ws endpoint
+        self._ws_root_base_url = ws_url
+        self.base_url = f"{ws_url}/livellm/ws"
+        self.timeout = timeout
+        self.websocket = None
+        # Lazily-created clients
+        self._transcription = None
+        self.max_size = max_size or 1024 * 1024 * 10 # 10MB is default max size
+        
+    async def connect(self):
+        """Establish WebSocket connection."""
+        if self.websocket is not None:
+            return self.websocket
+        
+        self.websocket = await websockets.connect(
+            self.base_url, 
+            open_timeout=self.timeout,
+            close_timeout=self.timeout,
+            max_size=self.max_size
+        )
+                
+        return self.websocket
+        
+    async def disconnect(self):
+        """Close WebSocket connection."""
+        if self.websocket is not None:
+            await self.websocket.close()
+            self.websocket = None
+    
+    async def get_response(self, action: WsAction, payload: dict) -> WsResponse:
+        """Send a request and wait for response."""
+        if self.websocket is None:
+            await self.connect()
+        
+        request = WsRequest(action=action, payload=payload)
+        await self.websocket.send(json.dumps(request.model_dump()))
+        
+        response_data = await self.websocket.recv()
+        response = WsResponse(**json.loads(response_data))
+        
+        if response.status == WsStatus.ERROR:
+            raise Exception(f"WebSocket request failed: {response.error}")
+        
+        return response
+    
+    async def get_response_stream(self, action: WsAction, payload: dict) -> AsyncIterator[WsResponse]:
+        """Send a request and stream responses."""
+        if self.websocket is None:
+            await self.connect()
+        
+        request = WsRequest(action=action, payload=payload)
+        await self.websocket.send(json.dumps(request.model_dump()))
+        
+        while True:
+            response_data = await self.websocket.recv()
+            response = WsResponse(**json.loads(response_data))
+            
+            if response.status == WsStatus.ERROR:
+                raise Exception(f"WebSocket stream failed: {response.error}")
+            
+            yield response
+            
+            if response.status == WsStatus.SUCCESS:
+                break
+    
+    # Implement abstract methods from BaseLivellmClient
+    
+    async def handle_agent_run(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AgentResponse:
+        """Handle agent run via WebSocket."""
+        response = await self.get_response(
+            WsAction.AGENT_RUN,
+            request.model_dump()
+        )
+        return AgentResponse(**response.data)
+    
+    async def handle_agent_run_stream(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AsyncIterator[AgentResponse]:
+        """Handle streaming agent run via WebSocket."""
+        async for response in self.get_response_stream(WsAction.AGENT_RUN_STREAM, request.model_dump()):
+            yield AgentResponse(**response.data)
+    
+    async def handle_speak(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> EncodedSpeakResponse:
+        """Handle speak request via WebSocket."""
+        response = await self.get_response(
+            WsAction.AUDIO_SPEAK,
+            request.model_dump()
+        )
+        return EncodedSpeakResponse(**response.data)
+    
+    async def handle_speak_stream(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> AsyncIterator[EncodedSpeakResponse]:
+        """Handle streaming speak request via WebSocket."""
+        async for response in self.get_response_stream(WsAction.AUDIO_SPEAK_STREAM, request.model_dump()):
+            yield EncodedSpeakResponse(**response.data)
+    
+    async def handle_transcribe(self, request: Union[TranscribeRequest, TranscribeFallbackRequest]) -> TranscribeResponse:
+        """Handle transcribe request via WebSocket."""
+        response = await self.get_response(
+            WsAction.AUDIO_TRANSCRIBE,
+            request.model_dump()
+        )
+        return TranscribeResponse(**response.data)
+    
+    # Context manager support
+    
+    async def __aenter__(self):
+        await self.connect()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.disconnect()
+
+    @property
+    def transcription(self) -> TranscriptionWsClient:
+        """
+        Lazily-initialized WebSocket transcription client that shares the same
+        server base URL and timeout as this realtime client.
+        """
+        if self._transcription is None:
+            # Use the ws root (e.g. ws://host:port) and let TranscriptionWsClient
+            # append its own /livellm/ws/transcription path.
+            self._transcription = TranscriptionWsClient(
+                base_url=self._ws_root_base_url,
+                timeout=self.timeout,
+            )
+        return self._transcription
+
+class LivellmClient(BaseLivellmClient):
+    """HTTP-based LiveLLM client for request-response communication."""
+
+    def __init__(
+        self, 
+        base_url: str, 
+        timeout: Optional[float] = None,
+        configs: Optional[List[Settings]] = None
+        ):
+        # Root server URL (http/https, without trailing slash)
+        self._root_base_url = base_url.rstrip("/")
+        # HTTP API base URL for this client
+        self.base_url = f"{self._root_base_url}/livellm"
+        self.timeout = timeout
+        self.client = httpx.AsyncClient(base_url=self.base_url, timeout=self.timeout) \
+            if self.timeout else httpx.AsyncClient(base_url=self.base_url)
+        self.settings = []
+        self.headers = {
+            "Content-Type": "application/json",
         }
-        result = await self.post_multipart(files, data, "audio/transcribe")
-        return TranscribeResponse(**result)
-         
+        # Lazily-created realtime (WebSocket) client
+        self._realtime = None
+        if configs:
+            self.update_configs_post_init(configs)
 
+    @property
+    def realtime(self) -> LivellmWsClient:
+        """
+        Lazily-initialized WebSocket client for realtime operations (agent, audio, etc.)
+        that shares the same server base URL and timeout as this HTTP client.
+
+        Example:
+            client = LivellmClient(base_url=\"http://localhost:8000\")
+            async with client.realtime as session:
+                response = await session.agent_run(...)
+        """
+        if self._realtime is None:
+            # Pass the same root base URL; LivellmWsClient will handle ws/wss conversion.
+            self._realtime = LivellmWsClient(self._root_base_url, timeout=self.timeout)
+        return self._realtime
+    
+    def update_configs_post_init(self, configs: List[Settings]) -> SuccessResponse:
+        """
+        Update the configs after the client is initialized.
+        Args:
+            configs: The configs to update.
+        """
+        with httpx.Client(base_url=self.base_url, timeout=self.timeout) as client:
+            for config in configs:
+                response = client.post(f"{self.base_url}/providers/config", json=config.model_dump())
+                response.raise_for_status()
+                self.settings.append(config)
+            return SuccessResponse(success=True, message="Configs updated successfully")
+        
+
+    async def delete(self, endpoint: str) -> dict:
+        """
+        Delete a resource from the given endpoint and return the response.
+        Args:
+            endpoint: The endpoint to delete from.
+        Returns:
+            The response from the endpoint.
+        """
+        response = await self.client.delete(endpoint, headers=self.headers)
+        response.raise_for_status()
+        return response.json()
+    
+    async def post_multipart(
+        self,
+        files: dict,
+        data: dict,
+        endpoint: str
+    ) -> dict:
+        """
+        Post a multipart request to the given endpoint and return the response.
+        Args:
+            files: The files to send in the request.
+            data: The data to send in the request.
+            endpoint: The endpoint to post to.
+        Returns:
+            The response from the endpoint.
+        """
+        # Don't pass Content-Type header for multipart - httpx will set it automatically
+        response = await self.client.post(endpoint, files=files, data=data)
+        response.raise_for_status()
+        return response.json()
+    
+    
+    async def get(
+        self,
+        endpoint: str
+    ) -> dict:
+        """
+        Get a request from the given endpoint and return the response.
+        Args:
+            endpoint: The endpoint to get from.
+        Returns:
+            The response from the endpoint.
+        """
+        response = await self.client.get(endpoint, headers=self.headers)
+        response.raise_for_status()
+        return response.json()
+    
+    async def post(
+        self, 
+        json_data: dict, 
+        endpoint: str, 
+        expect_stream: bool = False, 
+        expect_json: bool = True
+    ) -> Union[dict, bytes, AsyncIterator[Union[dict, bytes]]]:
+        """
+        Post a request to the given endpoint and return the response.
+        If expect_stream is True, return an AsyncIterator of the response.
+        If expect_json is True, return the response as a JSON object.
+        Otherwise, return the response as bytes.
+        Args:
+            json_data: The JSON data to send in the request.
+            endpoint: The endpoint to post to.
+            expect_stream: Whether to expect a stream response.
+            expect_json: Whether to expect a JSON response.
+        Returns:
+            The response from the endpoint.
+        Raises:
+            Exception: If the response is not 200 or 201.
+        """
+        response = await self.client.post(endpoint, json=json_data, headers=self.headers)
+        if response.status_code not in [200, 201]:
+            error_response = await response.aread()
+            error_response = error_response.decode("utf-8")
+            raise Exception(f"Failed to post to {endpoint}: {error_response}")
+        if expect_stream:
+            async def json_stream_response() -> AsyncIterator[dict]:
+                async for chunk in response.aiter_lines():
+                    chunk = chunk.strip()
+                    if not chunk:
+                        continue
+                    yield json.loads(chunk)
+            async def bytes_stream_response() -> AsyncIterator[bytes]:
+                async for chunk in response.aiter_bytes():
+                    yield chunk
+            stream_response = json_stream_response if expect_json else bytes_stream_response
+            return stream_response()
+        else:
+            if expect_json:
+                return response.json()
+            else:
+                return response.content
+    
+    async def ping(self) -> SuccessResponse:
+        result = await self.get("ping")
+        return SuccessResponse(**result)
+    
+    async def update_config(self, config: Settings) -> SuccessResponse:
+        result = await self.post(config.model_dump(), "providers/config", expect_json=True)
+        self.settings.append(config)
+        return SuccessResponse(**result)
+    
+    async def update_configs(self, configs: List[Settings]) -> SuccessResponse:
+        for config in configs:
+            await self.update_config(config)
+        return SuccessResponse(success=True, message="Configs updated successfully")
+    
+    async def get_configs(self) -> List[Settings]:
+        result = await self.get("providers/configs")
+        return [Settings(**config) for config in result]
+    
+    async def delete_config(self, config_uid: str) -> SuccessResponse:
+        result = await self.delete(f"providers/config/{config_uid}")
+        return SuccessResponse(**result)
+    
+    async def cleanup(self):
+        """
+        Delete all the created settings resources and close the client.
+        Should be called when you're done using the client.
+        """
+        for config in self.settings:
+            config: Settings = config
+            await self.delete_config(config.uid)
+        await self.client.aclose()
+        # Also close any realtime WebSocket client if it was created
+        if self._realtime is not None:
+            await self._realtime.disconnect()
+        
+    def __del__(self):
+        """
+        Destructor to clean up resources when the client is garbage collected.
+        This will close the HTTP client and attempt to delete configs if cleanup wasn't called.
+        Note: It's recommended to use the async context manager or call cleanup() explicitly.
+        """
+        # Warn user if cleanup wasn't called
+        if self.settings:
+            warnings.warn(
+                "LivellmClient is being garbage collected without explicit cleanup. "
+                "Provider configs may not be deleted from the server. "
+                "Consider using 'async with' or calling 'await client.cleanup()' explicitly.",
+                ResourceWarning,
+                stacklevel=2
+            )
         
+        # Close the httpx client synchronously
+        # httpx.AsyncClient stores a sync Transport that needs cleanup
+        try:
+            with httpx.Client(base_url=self.base_url) as client:
+                for config in self.settings:
+                    config: Settings = config
+                    client.delete("providers/config/{config.uid}", headers=self.headers)
+        except Exception:
+            # Silently fail - we're in a destructor
+            pass
+
+    # Implement abstract methods from BaseLivellmClient
+    
+    async def handle_agent_run(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AgentResponse:
+        """Handle agent run via HTTP."""
+        result = await self.post(request.model_dump(), "agent/run", expect_json=True)
+        return AgentResponse(**result)
+    
+    async def handle_agent_run_stream(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AsyncIterator[AgentResponse]:
+        """Handle streaming agent run via HTTP."""
+        stream = await self.post(request.model_dump(), "agent/run_stream", expect_stream=True, expect_json=True)
+        async for chunk in stream:
+            yield AgentResponse(**chunk)
+    
+    async def handle_speak(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> bytes:
+        """Handle speak request via HTTP."""
+        return await self.post(request.model_dump(), "audio/speak", expect_json=False)
+    
+    async def handle_speak_stream(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> AsyncIterator[bytes]:
+        """Handle streaming speak request via HTTP."""
+        speak_stream = await self.post(request.model_dump(), "audio/speak_stream", expect_stream=True, expect_json=False)
+        async for chunk in speak_stream:
+            yield chunk
+    
+    async def handle_transcribe(self, request: Union[TranscribeRequest, TranscribeFallbackRequest]) -> TranscribeResponse:
+        """Handle transcribe request via HTTP."""
+        result = await self.post(request.model_dump(), "audio/transcribe_json", expect_json=True)
+        return TranscribeResponse(**result)
 

livellm/models/__init__.py

@@ -5,6 +5,7 @@ from .agent.chat import Message, MessageRole, TextMessage, BinaryMessage
 from .agent.tools import Tool, ToolInput, ToolKind, WebSearchInput, MCPStreamableServerInput
 from .audio.speak import SpeakMimeType, SpeakRequest, SpeakStreamResponse
 from .audio.transcribe import TranscribeRequest, TranscribeResponse, File
+from .transcription import TranscriptionInitWsRequest, TranscriptionAudioChunkWsRequest, TranscriptionWsResponse
 
 
 __all__ = [
@@ -38,4 +39,8 @@ __all__ = [
     "TranscribeRequest",
     "TranscribeResponse",
     "File",
+    # Real-time Transcription
+    "TranscriptionInitWsRequest",
+    "TranscriptionAudioChunkWsRequest",
+    "TranscriptionWsResponse",
 ]

livellm/models/audio/speak.py

@@ -2,6 +2,7 @@ from pydantic import BaseModel, Field, field_validator
 from typing import Optional, TypeAlias, Tuple, AsyncIterator
 from enum import Enum
 from ..common import BaseRequest
+import base64
 
 SpeakStreamResponse: TypeAlias = Tuple[AsyncIterator[bytes], str, int]
 
@@ -21,3 +22,23 @@ class SpeakRequest(BaseRequest):
     sample_rate: int = Field(..., description="The target sample rate of the output audio")
     chunk_size: int = Field(default=20, description="Chunk size in milliseconds for streaming (default: 20ms)")
     gen_config: Optional[dict] = Field(default=None, description="The configuration for the generation")
+
+class EncodedSpeakResponse(BaseModel):
+    audio: bytes | str = Field(..., description="The audio data as a base64 encoded string")
+    content_type: SpeakMimeType = Field(..., description="The content type of the audio")
+    sample_rate: int = Field(..., description="The sample rate of the audio")
+
+    @field_validator("audio", mode="after")
+    @classmethod
+    def validate_audio(cls, v: bytes | str) -> bytes:
+        """
+        Ensure that `audio` is always returned as raw bytes.
+
+        - If the server returns a base64-encoded *string*, decode it.
+        - If the server already returned raw bytes, pass them through.
+        """
+        if isinstance(v, str):
+            # Server sent base64-encoded string → decode to raw bytes
+            return base64.b64decode(v)
+        # Already bytes → assume it's raw audio
+        return v

livellm/models/transcription.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, Field, field_validator
+from livellm.models.audio.speak import SpeakMimeType
+import base64
+
+class TranscriptionInitWsRequest(BaseModel):
+    provider_uid: str = Field(..., description="The provider uid")
+    model: str = Field(..., description="The model")
+    language: str = Field(default="auto", description="The language")
+    input_sample_rate: int = Field(default=24000, description="The input sample rate")
+    input_audio_format: SpeakMimeType = Field(default=SpeakMimeType.PCM, description="The input audio format (pcm, ulaw, alaw)")
+    gen_config: dict = Field(default={}, description="The generation configuration")
+
+
+class TranscriptionAudioChunkWsRequest(BaseModel):
+    audio: str = Field(..., description="The audio (base64 encoded)")
+
+    @field_validator('audio', mode='before')
+    @classmethod
+    def validate_audio(cls, v: str | bytes) -> str:
+        """
+        encode audio to base64 string if needed
+        """
+        if isinstance(v, bytes):
+            return base64.b64encode(v).decode("utf-8")
+        elif isinstance(v, str):
+            return v # already base64 encoded
+        else:
+            raise ValueError(f"Invalid audio type: {type(v)}")
+
+class TranscriptionWsResponse(BaseModel):
+    transcription: str = Field(..., description="The transcription")
+    is_end: bool = Field(..., description="Whether the response is the end of the transcription")

livellm/models/ws.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel, Field
+from enum import Enum
+from typing import Union, Optional
+
+class WsAction(str, Enum):
+    AGENT_RUN = "agent_run"
+    AGENT_RUN_STREAM = "agent_run_stream"
+    AUDIO_SPEAK = "audio_speak"
+    AUDIO_SPEAK_STREAM = "audio_speak_stream"
+    AUDIO_TRANSCRIBE = "audio_transcribe"
+    TRANSCRIPTION_SESSION = "transcription_session"
+
+
+class WsStatus(str, Enum):
+    STREAMING = "streaming"
+    SUCCESS = "success"
+    ERROR = "error"
+
+class WsRequest(BaseModel):
+    action: WsAction = Field(..., description="The action to perform")
+    payload: Union[dict, BaseModel] = Field(..., description="The payload for the action")
+
+
+class WsResponse(BaseModel):
+    status: WsStatus = Field(..., description="The status of the response")
+    action: WsAction = Field(..., description="The action that was performed")
+    data: Union[dict, BaseModel] = Field(..., description="The data for the response")
+    error: Optional[str] = Field(default=None, description="The error message if the response is an error")

livellm/transcripton.py

@@ -0,0 +1,116 @@
+from livellm.models.transcription import (
+    TranscriptionInitWsRequest, 
+    TranscriptionAudioChunkWsRequest, 
+    TranscriptionWsResponse)
+from livellm.models.ws import WsResponse, WsStatus
+from typing import Optional, AsyncIterator
+import websockets
+import asyncio
+import json
+
+
+class TranscriptionWsClient:
+    def __init__(self, base_url: str, timeout: Optional[float] = None, max_size: Optional[int] = None):
+        self.base_url = base_url.rstrip("/")
+        self.url = f"{base_url}/livellm/ws/transcription"
+        self.timeout = timeout
+        self.websocket = None
+        self.max_size = max_size or 1024 * 1024 * 10 # 10MB is default max size
+    
+    async def connect(self):
+        """
+        Connect to the transcription websocket server.
+        """
+        self.websocket = await websockets.connect(
+            self.url,
+            open_timeout=self.timeout,
+            close_timeout=self.timeout,
+            max_size=self.max_size
+        )
+    
+    async def disconnect(self):
+        """
+        Disconnect from the transcription websocket server.
+        """
+        if self.websocket is not None:
+            await self.websocket.close()
+            self.websocket = None
+    
+    async def __aenter__(self):
+        await self.connect()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.disconnect()
+    
+    async def start_session(
+        self, 
+        request: TranscriptionInitWsRequest, 
+        source: AsyncIterator[TranscriptionAudioChunkWsRequest]
+    ) -> AsyncIterator[TranscriptionWsResponse]:
+        """
+        Start a transcription session.
+        
+        Args:
+            request: The initialization request for the transcription session.
+            source: An async iterator that yields audio chunks to transcribe.
+            
+        Returns:
+            An async iterator of transcription session responses.
+            
+        Example:
+            ```python
+            async def audio_source():
+                with open("audio.pcm", "rb") as f:
+                    while chunk := f.read(4096):
+                        yield TranscriptionAudioChunkWsRequest(audio=chunk)
+            
+            async with TranscriptionWsClient(url) as client:
+                async for response in client.start_session(init_request, audio_source()):
+                    print(response.transcription)
+                    if response.is_end:
+                        break
+            ```
+        """
+        # Send initialization request
+        await self.websocket.send(request.model_dump_json())
+        
+        # Wait for initialization response
+        response_data = await self.websocket.recv()
+        response = WsResponse(**json.loads(response_data))
+        if response.status == WsStatus.ERROR:
+            raise Exception(f"Failed to start transcription session: {response.error}")
+
+        # Start sending audio chunks in background
+        async def send_chunks():
+            try:
+                async for chunk in source:
+                    await self.websocket.send(chunk.model_dump_json())
+            except Exception as e:
+                # If there's an error sending chunks, close the websocket
+                print(f"Error sending chunks: {e}")
+                await self.websocket.close()
+                raise e
+        
+        send_task = asyncio.create_task(send_chunks())
+        
+        # Receive transcription responses
+        try:
+            while not send_task.done():
+                response_data = await self.websocket.recv()
+                transcription_response = TranscriptionWsResponse(**json.loads(response_data))
+                yield transcription_response
+                
+                # Stop if we received the final transcription
+                if transcription_response.is_end:
+                    break
+        except websockets.ConnectionClosed:
+            pass
+        finally:
+            # Cancel the send task if still running
+            if not send_task.done():
+                send_task.cancel()
+                try:
+                    await send_task
+                except asyncio.CancelledError:
+                    pass

{livellm-1.2.0.dist-info → livellm-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: livellm
-Version: 1.2.0
+Version: 1.3.5
 Summary: Python client for the LiveLLM Server
 Project-URL: Homepage, https://github.com/qalby-tech/livellm-client-py
 Project-URL: Repository, https://github.com/qalby-tech/livellm-client-py
@@ -17,6 +17,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: websockets>=15.0.1
 Provides-Extra: testing
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'testing'
 Requires-Dist: pytest-cov>=4.1.0; extra == 'testing'
@@ -32,12 +33,13 @@ Python client library for the LiveLLM Server - a unified proxy for AI agent, aud
 
 ## Features
 
-- 🚀 **Async-first** - Built on httpx for high-performance operations
+- 🚀 **Async-first** - Built on httpx and websockets for high-performance operations
 - 🔒 **Type-safe** - Full type hints and Pydantic validation
 - 🎯 **Multi-provider** - OpenAI, Google, Anthropic, Groq, ElevenLabs
 - 🔄 **Streaming** - Real-time streaming for agent and audio
 - 🛠️ **Flexible API** - Use request objects or keyword arguments
 - 🎙️ **Audio services** - Text-to-speech and transcription
+- 🎤 **Real-Time Transcription** - WebSocket-based live audio transcription with bidirectional streaming
 - ⚡ **Fallback strategies** - Sequential and parallel handling
 - 🧹 **Auto cleanup** - Context managers and garbage collection
 
@@ -326,6 +328,123 @@ transcription = await client.transcribe(
 )
 ```
 
+### Real-Time Transcription (WebSocket)
+
+The realtime transcription API is available either **directly** via `TranscriptionWsClient` or **through** `LivellmClient.realtime.transcription`.
+
+#### Using `TranscriptionWsClient` directly
+
+```python
+import asyncio
+from livellm import TranscriptionWsClient
+from livellm.models import (
+    TranscriptionInitWsRequest,
+    TranscriptionAudioChunkWsRequest,
+    SpeakMimeType,
+)
+
+async def transcribe_live_direct():
+    base_url = "ws://localhost:8000"  # WebSocket base URL
+
+    async with TranscriptionWsClient(base_url, timeout=30) as client:
+        # Define audio source (file, microphone, stream, etc.)
+        async def audio_source():
+            with open("audio.pcm", "rb") as f:
+                while chunk := f.read(4096):
+                    yield TranscriptionAudioChunkWsRequest(audio=chunk)
+                    await asyncio.sleep(0.1)  # Simulate real-time
+
+        # Initialize transcription session
+        init_request = TranscriptionInitWsRequest(
+            provider_uid="openai",
+            model="gpt-4o-mini-transcribe",
+            language="en",  # or "auto" for detection
+            input_sample_rate=24000,
+            input_audio_format=SpeakMimeType.PCM,
+            gen_config={},
+        )
+
+        # Stream audio and receive transcriptions
+        async for response in client.start_session(init_request, audio_source()):
+            print(f"Transcription: {response.transcription}")
+            if response.is_end:
+                print("Transcription complete!")
+                break
+
+asyncio.run(transcribe_live_direct())
+```
+
+#### Using `LivellmClient.realtime.transcription` (and running agents while listening)
+
+```python
+import asyncio
+from livellm import LivellmClient
+from livellm.models import (
+    TextMessage,
+    TranscriptionInitWsRequest,
+    TranscriptionAudioChunkWsRequest,
+    SpeakMimeType,
+)
+
+async def transcribe_and_chat():
+    # Central HTTP client; .realtime and .transcription expose WebSocket APIs
+    client = LivellmClient(base_url="http://localhost:8000", timeout=30)
+
+    async with client.realtime as realtime:
+        async with realtime.transcription as t_client:
+            async def audio_source():
+                with open("audio.pcm", "rb") as f:
+                    while chunk := f.read(4096):
+                        yield TranscriptionAudioChunkWsRequest(audio=chunk)
+                        await asyncio.sleep(0.1)
+
+            init_request = TranscriptionInitWsRequest(
+                provider_uid="openai",
+                model="gpt-4o-mini-transcribe",
+                language="en",
+                input_sample_rate=24000,
+                input_audio_format=SpeakMimeType.PCM,
+                gen_config={},
+            )
+
+            # Listen for transcriptions and, for each chunk, run an agent request
+            async for resp in t_client.start_session(init_request, audio_source()):
+                print("User said:", resp.transcription)
+
+                # You can call agent_run (or speak, etc.) while the transcription stream is active
+                agent_response = await realtime.agent_run(
+                    provider_uid="openai",
+                    model="gpt-4",
+                    messages=[
+                        TextMessage(role="user", content=resp.transcription),
+                    ],
+                    temperature=0.7,
+                )
+                print("Agent:", agent_response.output)
+
+                if resp.is_end:
+                    print("Transcription session complete")
+                    break
+
+asyncio.run(transcribe_and_chat())
+```
+
+**Supported Audio Formats:**
+- **PCM**: 16-bit uncompressed (recommended)
+- **μ-law**: 8-bit telephony format (North America/Japan)
+- **A-law**: 8-bit telephony format (Europe/rest of world)
+
+**Use Cases:**
+- 🎙️ Voice assistants and chatbots
+- 📝 Live captioning and subtitles
+- 🎤 Meeting transcription
+- 🗣️ Voice commands and control
+
+**See also:** 
+- [TRANSCRIPTION_CLIENT.md](TRANSCRIPTION_CLIENT.md) - Complete transcription guide
+- [example_transcription.py](example_transcription.py) - Python examples
+- [example_transcription_browser.html](example_transcription_browser.html) - Browser demo
+
 ### Fallback Strategies
 
 Handle failures automatically with sequential or parallel fallback:
@@ -418,6 +537,12 @@ response = await client.ping()
 - `speak_stream(request | **kwargs)` - Text-to-speech (streaming)
 - `transcribe(request | **kwargs)` - Speech-to-text
 
+**Real-Time Transcription (TranscriptionWsClient)**
+- `connect()` - Establish WebSocket connection
+- `disconnect()` - Close WebSocket connection
+- `start_session(init_request, audio_source)` - Start bidirectional streaming transcription
+- `async with client:` - Auto connection management (recommended)
+
 **Cleanup**
 - `cleanup()` - Release resources
 - `async with client:` - Auto cleanup (recommended)
@@ -437,6 +562,8 @@ response = await client.ping()
 - `AgentRequest(provider_uid, model, messages, tools?, gen_config?)`
 - `SpeakRequest(provider_uid, model, text, voice, mime_type, sample_rate, gen_config?)`
 - `TranscribeRequest(provider_uid, file, model, language?, gen_config?)`
+- `TranscriptionInitWsRequest(provider_uid, model, language?, input_sample_rate?, input_audio_format?, gen_config?)`
+- `TranscriptionAudioChunkWsRequest(audio)` - Audio chunk for streaming
 
 **Tools**
 - `WebSearchInput(kind=ToolKind.WEB_SEARCH, search_context_size)`
@@ -450,6 +577,7 @@ response = await client.ping()
 **Responses**
 - `AgentResponse(output, usage{input_tokens, output_tokens}, ...)`
 - `TranscribeResponse(text, language)`
+- `TranscriptionWsResponse(transcription, is_end)` - Real-time transcription result
 
 ## Error Handling
 
@@ -486,6 +614,15 @@ mypy livellm
 - Python 3.10+
 - httpx >= 0.27.0
 - pydantic >= 2.0.0
+- websockets >= 15.0.1
+
+## Documentation
+
+- [README.md](README.md) - Main documentation (you are here)
+- [TRANSCRIPTION_CLIENT.md](TRANSCRIPTION_CLIENT.md) - Complete real-time transcription guide
+- [CLIENT_EXAMPLES.md](CLIENT_EXAMPLES.md) - Usage examples for all features
+- [example_transcription.py](example_transcription.py) - Python transcription examples
+- [example_transcription_browser.html](example_transcription_browser.html) - Browser demo
 
 ## Links
 

livellm-1.3.5.dist-info/RECORD

@@ -0,0 +1,20 @@
+livellm/__init__.py,sha256=p2Szx7PELGYi-PTnSNnRPGVbU438ZBTFXYAQoMToUfE,440
+livellm/livellm.py,sha256=I-XloiBFxR41Xvd7UCzg5ipztcrfT6EVyt8KAni-rgo,32291
+livellm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livellm/transcripton.py,sha256=2ttPzc8A6uQL5VouLLb4aj7Q-cMCx3V1HXH2qhpUMfM,4195
+livellm/models/__init__.py,sha256=tCX_Q3ALjO0jbqhLFsVoITSm1AV--3pF5ZZc_l0VC1o,1447
+livellm/models/common.py,sha256=YqRwP6ChWbRdoen4MU6RO4u6HeM0mQJbXiiRV4DuauM,1740
+livellm/models/fallback.py,sha256=zGG_MjdbaTx0fqKZTEg3ullej-CJznPfwaon0jEvRvI,1170
+livellm/models/transcription.py,sha256=fl2iiD2ET_KbsB2hUyruUjkZEvIRZ-cD22MIMewtYRA,1423
+livellm/models/ws.py,sha256=Ij1gCPzr86XW7mwo6tT99ImdcXCYn6jkvnNPLvimYhU,1037
+livellm/models/agent/__init__.py,sha256=KVm6AgQoWEaoq47QAG4Ou4NimoXOTkjXC-0-gnMRLZ8,476
+livellm/models/agent/agent.py,sha256=-UcGv5Bzw5ALmWX4lIqpbWqMVjCsjBc0KIE6_JKbCXM,1106
+livellm/models/agent/chat.py,sha256=zGfeEHx0luwq23pqWF1megcuEDUl6IhV4keLJeZry_A,1028
+livellm/models/agent/tools.py,sha256=wVWfx6_jxL3IcmX_Nt_PonZ3RQLtpfqJnszHz32BQiU,1403
+livellm/models/audio/__init__.py,sha256=sz2NxCOfFGVvp-XQUsdgOR_TYBO1Wb-8LLXaZDEiAZk,282
+livellm/models/audio/speak.py,sha256=lDITZ7fiLRuDhA-LxCPQ6Yraxr33B6Lg7VyR4CkuGk8,1872
+livellm/models/audio/transcribe.py,sha256=Leji2lk5zfq4GE-fw-z2dZR8BuijzW8TJ12GHw_UZJY,2085
+livellm-1.3.5.dist-info/METADATA,sha256=goAVH_VH2pe_xGnKslqbgBgoui03iDWaSwDDQERDIbs,18701
+livellm-1.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+livellm-1.3.5.dist-info/licenses/LICENSE,sha256=yapGO2C_00ymEx6TADdbU8Oyc1bWOrZY-fjP-agmFL4,1071
+livellm-1.3.5.dist-info/RECORD,,

livellm-1.2.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-livellm/__init__.py,sha256=JG_0-UCfQI_3D0Y2PzobZLS5OhJwK76i8t81ye0KpfY,279
-livellm/livellm.py,sha256=w6Dc0eewOSJie4rmfMq-afck6Coh30-KmkRNh9_Eeko,24003
-livellm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-livellm/models/__init__.py,sha256=JBUd1GkeDexLSdjSOcUet78snu0NNxnhU7mBN3BhqIA,1199
-livellm/models/common.py,sha256=YqRwP6ChWbRdoen4MU6RO4u6HeM0mQJbXiiRV4DuauM,1740
-livellm/models/fallback.py,sha256=zGG_MjdbaTx0fqKZTEg3ullej-CJznPfwaon0jEvRvI,1170
-livellm/models/agent/__init__.py,sha256=KVm6AgQoWEaoq47QAG4Ou4NimoXOTkjXC-0-gnMRLZ8,476
-livellm/models/agent/agent.py,sha256=-UcGv5Bzw5ALmWX4lIqpbWqMVjCsjBc0KIE6_JKbCXM,1106
-livellm/models/agent/chat.py,sha256=zGfeEHx0luwq23pqWF1megcuEDUl6IhV4keLJeZry_A,1028
-livellm/models/agent/tools.py,sha256=wVWfx6_jxL3IcmX_Nt_PonZ3RQLtpfqJnszHz32BQiU,1403
-livellm/models/audio/__init__.py,sha256=sz2NxCOfFGVvp-XQUsdgOR_TYBO1Wb-8LLXaZDEiAZk,282
-livellm/models/audio/speak.py,sha256=KvENOE_Lf8AWBhzCMqu1dqGYv4WqaLf7fuWz8OYfJo8,1006
-livellm/models/audio/transcribe.py,sha256=Leji2lk5zfq4GE-fw-z2dZR8BuijzW8TJ12GHw_UZJY,2085
-livellm-1.2.0.dist-info/METADATA,sha256=aF-sHBOn1GDj8-u6RNwYYdto5dyRbeIHjWbAMBiFR0Q,13284
-livellm-1.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-livellm-1.2.0.dist-info/licenses/LICENSE,sha256=yapGO2C_00ymEx6TADdbU8Oyc1bWOrZY-fjP-agmFL4,1071
-livellm-1.2.0.dist-info/RECORD,,