livellm 1.5.5__py3-none-any.whl → 1.7.1__py3-none-any.whl

livellm/livellm.py

@@ -3,9 +3,10 @@ import asyncio
 import httpx
 import json
 import warnings
-from typing import List, Optional, AsyncIterator, Union, overload, Dict
+from typing import List, Optional, AsyncIterator, Union, overload, Dict, Any, Type
 from .models.common import Settings, SuccessResponse
 from .models.agent.agent import AgentRequest, AgentResponse
+from .models.agent.output_schema import OutputSchema
 from .models.audio.speak import SpeakRequest, EncodedSpeakResponse
 from .models.audio.transcribe import TranscribeRequest, TranscribeResponse, File
 from .models.fallback import AgentFallbackRequest, AudioFallbackRequest, TranscribeFallbackRequest
@@ -15,16 +16,30 @@ from .transcripton import TranscriptionWsClient
 from uuid import uuid4
 import logging
 from abc import ABC, abstractmethod
+from importlib.metadata import version, PackageNotFoundError
+from pydantic import BaseModel
 
 
 logger = logging.getLogger(__name__)
 
+try:
+    __version__ = version("livellm")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+DEFAULT_USER_AGENT = f"livellm-python/{__version__}"
+
 class BaseLivellmClient(ABC):
 
+    # Default timeout (set by subclasses)
+    timeout: Optional[float] = None
+
     @overload
     async def agent_run(
         self,
         request: Union[AgentRequest, AgentFallbackRequest],
+        *,
+        timeout: Optional[float] = None,
     ) -> AgentResponse:
         ...
     
@@ -37,13 +52,19 @@ class BaseLivellmClient(ABC):
         messages: list,
         tools: Optional[list] = None,
         include_history: bool = False,
+        output_schema: Optional[Union[OutputSchema, Dict[str, Any], Type[BaseModel]]] = None,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> AgentResponse:
         ...
     
     
     @abstractmethod
-    async def handle_agent_run(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AgentResponse:
+    async def handle_agent_run(
+        self, 
+        request: Union[AgentRequest, AgentFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> AgentResponse:
         ...
     
     async def agent_run(
@@ -55,6 +76,8 @@ class BaseLivellmClient(ABC):
         messages: Optional[list] = None,
         tools: Optional[list] = None,
         include_history: bool = False,
+        output_schema: Optional[Union[OutputSchema, Dict[str, Any], Type[BaseModel]]] = None,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> AgentResponse:
         """
@@ -72,7 +95,8 @@ class BaseLivellmClient(ABC):
                model="gpt-4",
                messages=[TextMessage(...)],
                tools=[],
-               include_history=False
+               include_history=False,
+               output_schema=MyPydanticModel  # or OutputSchema(...) or dict
            )
         
         Args:
@@ -83,9 +107,15 @@ class BaseLivellmClient(ABC):
             tools: Optional list of tools
             gen_config: Optional generation configuration
             include_history: Whether to include full conversation history in the response
+            output_schema: Optional schema for structured output. Can be:
+                - An OutputSchema instance
+                - A dict representing a JSON schema
+                - A Pydantic BaseModel class (will be converted to OutputSchema)
+            timeout: Optional timeout in seconds (overrides default client timeout)
             
         Returns:
-            AgentResponse with the agent's output
+            AgentResponse with the agent's output. If output_schema was provided,
+            the output will be a JSON string matching the schema.
         """
         # Check if first argument is a request object
         if request is not None:
@@ -93,7 +123,7 @@ class BaseLivellmClient(ABC):
                 raise TypeError(
                     f"First positional argument must be AgentRequest or AgentFallbackRequest, got {type(request)}"
                 )
-            return await self.handle_agent_run(request)
+            return await self.handle_agent_run(request, timeout=timeout)
     
         # Otherwise, use keyword arguments
         if provider_uid is None or model is None or messages is None:
@@ -102,20 +132,45 @@ class BaseLivellmClient(ABC):
                 "Alternatively, pass an AgentRequest object as the first positional argument."
             )
         
+        # Convert output_schema if it's a Pydantic BaseModel class
+        resolved_schema = self._resolve_output_schema(output_schema)
+        
         agent_request = AgentRequest(
             provider_uid=provider_uid,
             model=model,
             messages=messages,
             tools=tools or [],
             gen_config=kwargs or None,
-            include_history=include_history
+            include_history=include_history,
+            output_schema=resolved_schema
         )
-        return await self.handle_agent_run(agent_request)
+        return await self.handle_agent_run(agent_request, timeout=timeout)
+    
+    def _resolve_output_schema(
+        self, 
+        output_schema: Optional[Union[OutputSchema, Dict[str, Any], Type[BaseModel]]]
+    ) -> Optional[Union[OutputSchema, Dict[str, Any]]]:
+        """
+        Resolve the output_schema parameter to an OutputSchema or dict.
+        
+        If a Pydantic BaseModel class is provided, convert it to OutputSchema.
+        """
+        if output_schema is None:
+            return None
+        
+        # Check if it's a class (not an instance) that's a subclass of BaseModel
+        if isinstance(output_schema, type) and issubclass(output_schema, BaseModel):
+            return OutputSchema.from_pydantic(output_schema)
+        
+        # Already an OutputSchema or dict, return as-is
+        return output_schema
     
     @overload
     def agent_run_stream(
         self,
         request: Union[AgentRequest, AgentFallbackRequest],
+        *,
+        timeout: Optional[float] = None,
     ) -> AsyncIterator[AgentResponse]:
         ...
     
@@ -128,13 +183,19 @@ class BaseLivellmClient(ABC):
         messages: list,
         tools: Optional[list] = None,
         include_history: bool = False,
+        output_schema: Optional[Union[OutputSchema, Dict[str, Any], Type[BaseModel]]] = None,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> AsyncIterator[AgentResponse]:
         ...
     
     
     @abstractmethod
-    async def handle_agent_run_stream(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AsyncIterator[AgentResponse]:
+    async def handle_agent_run_stream(
+        self, 
+        request: Union[AgentRequest, AgentFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> AsyncIterator[AgentResponse]:
         ...
     
     async def agent_run_stream(
@@ -146,6 +207,8 @@ class BaseLivellmClient(ABC):
         messages: Optional[list] = None,
         tools: Optional[list] = None,
         include_history: bool = False,
+        output_schema: Optional[Union[OutputSchema, Dict[str, Any], Type[BaseModel]]] = None,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> AsyncIterator[AgentResponse]:
         """
@@ -165,7 +228,8 @@ class BaseLivellmClient(ABC):
                model="gpt-4",
                messages=[TextMessage(...)],
                tools=[],
-               include_history=False
+               include_history=False,
+               output_schema=MyPydanticModel  # or OutputSchema(...) or dict
            ):
                ...
         
@@ -177,9 +241,15 @@ class BaseLivellmClient(ABC):
             tools: Optional list of tools
             gen_config: Optional generation configuration
             include_history: Whether to include full conversation history in the response
+            output_schema: Optional schema for structured output. Can be:
+                - An OutputSchema instance
+                - A dict representing a JSON schema
+                - A Pydantic BaseModel class (will be converted to OutputSchema)
+            timeout: Optional timeout in seconds (overrides default client timeout)
             
         Returns:
-            AsyncIterator of AgentResponse chunks
+            AsyncIterator of AgentResponse chunks. If output_schema was provided,
+            the output will be a JSON string matching the schema.
         """
         # Check if first argument is a request object
         if request is not None:
@@ -187,7 +257,7 @@ class BaseLivellmClient(ABC):
                 raise TypeError(
                     f"First positional argument must be AgentRequest or AgentFallbackRequest, got {type(request)}"
                 )
-            stream = self.handle_agent_run_stream(request)
+            stream = self.handle_agent_run_stream(request, timeout=timeout)
         else:
             # Otherwise, use keyword arguments
             if provider_uid is None or model is None or messages is None:
@@ -196,15 +266,19 @@ class BaseLivellmClient(ABC):
                     "Alternatively, pass an AgentRequest object as the first positional argument."
                 )
             
+            # Convert output_schema if it's a Pydantic BaseModel class
+            resolved_schema = self._resolve_output_schema(output_schema)
+            
             agent_request = AgentRequest(
                 provider_uid=provider_uid,
                 model=model,
                 messages=messages,
                 tools=tools or [],
                 gen_config=kwargs or None,
-                include_history=include_history
+                include_history=include_history,
+                output_schema=resolved_schema
             )
-            stream = self.handle_agent_run_stream(agent_request)
+            stream = self.handle_agent_run_stream(agent_request, timeout=timeout)
         
         async for chunk in stream:
             yield chunk
@@ -213,6 +287,8 @@ class BaseLivellmClient(ABC):
     async def speak(
         self,
         request: Union[SpeakRequest, AudioFallbackRequest],
+        *,
+        timeout: Optional[float] = None,
     ) -> bytes:
         ...
     
@@ -227,13 +303,18 @@ class BaseLivellmClient(ABC):
         mime_type: str,
         sample_rate: int,
         chunk_size: int = 20,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> bytes:
         ...
     
     
     @abstractmethod
-    async def handle_speak(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> bytes:
+    async def handle_speak(
+        self, 
+        request: Union[SpeakRequest, AudioFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> bytes:
         ...
     
     async def speak(
@@ -247,6 +328,7 @@ class BaseLivellmClient(ABC):
         mime_type: Optional[str] = None,
         sample_rate: Optional[int] = None,
         chunk_size: int = 20,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> bytes:
         """
@@ -277,6 +359,7 @@ class BaseLivellmClient(ABC):
             mime_type: The MIME type of the output audio
             sample_rate: The sample rate of the output audio
             chunk_size: Chunk size in milliseconds (default: 20ms)
+            timeout: Optional timeout in seconds (overrides default client timeout)
             gen_config: Optional generation configuration
             
         Returns:
@@ -288,7 +371,7 @@ class BaseLivellmClient(ABC):
                 raise TypeError(
                     f"First positional argument must be SpeakRequest or AudioFallbackRequest, got {type(request)}"
                 )
-            return await self.handle_speak(request)
+            return await self.handle_speak(request, timeout=timeout)
         
         # 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:
@@ -307,12 +390,14 @@ class BaseLivellmClient(ABC):
             chunk_size=chunk_size,
             gen_config=kwargs or None
         )
-        return await self.handle_speak(speak_request)
+        return await self.handle_speak(speak_request, timeout=timeout)
     
     @overload
     def speak_stream(
         self,
         request: Union[SpeakRequest, AudioFallbackRequest],
+        *,
+        timeout: Optional[float] = None,
     ) -> AsyncIterator[bytes]:
         ...
     
@@ -327,13 +412,18 @@ class BaseLivellmClient(ABC):
         mime_type: str,
         sample_rate: int,
         chunk_size: int = 20,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> AsyncIterator[bytes]:
         ...
     
     
     @abstractmethod
-    async def handle_speak_stream(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> AsyncIterator[bytes]:
+    async def handle_speak_stream(
+        self, 
+        request: Union[SpeakRequest, AudioFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> AsyncIterator[bytes]:
         ...
     
     async def speak_stream(
@@ -347,6 +437,7 @@ class BaseLivellmClient(ABC):
         mime_type: Optional[str] = None,
         sample_rate: Optional[int] = None,
         chunk_size: int = 20,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> AsyncIterator[bytes]:
         """
@@ -380,6 +471,7 @@ class BaseLivellmClient(ABC):
             mime_type: The MIME type of the output audio
             sample_rate: The sample rate of the output audio
             chunk_size: Chunk size in milliseconds (default: 20ms)
+            timeout: Optional timeout in seconds (overrides default client timeout)
             gen_config: Optional generation configuration
             
         Returns:
@@ -391,7 +483,7 @@ class BaseLivellmClient(ABC):
                 raise TypeError(
                     f"First positional argument must be SpeakRequest or AudioFallbackRequest, got {type(request)}"
                 )
-            speak_stream = self.handle_speak_stream(request)
+            speak_stream = self.handle_speak_stream(request, timeout=timeout)
         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:
@@ -410,7 +502,7 @@ class BaseLivellmClient(ABC):
                 chunk_size=chunk_size,
                 gen_config=kwargs or None
             )
-            speak_stream = self.handle_speak_stream(speak_request)
+            speak_stream = self.handle_speak_stream(speak_request, timeout=timeout)
         async for chunk in speak_stream:
             yield chunk
     
@@ -418,6 +510,8 @@ class BaseLivellmClient(ABC):
     async def transcribe(
         self,
         request: Union[TranscribeRequest, TranscribeFallbackRequest],
+        *,
+        timeout: Optional[float] = None,
     ) -> TranscribeResponse:
         ...
     
@@ -429,13 +523,18 @@ class BaseLivellmClient(ABC):
         file: File,
         model: str,
         language: Optional[str] = None,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> TranscribeResponse:
         ...
         
     
     @abstractmethod
-    async def handle_transcribe(self, request: Union[TranscribeRequest, TranscribeFallbackRequest]) -> TranscribeResponse:
+    async def handle_transcribe(
+        self, 
+        request: Union[TranscribeRequest, TranscribeFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> TranscribeResponse:
         ...
     
     async def transcribe(
@@ -446,6 +545,7 @@ class BaseLivellmClient(ABC):
         file: Optional[File] = None,
         model: Optional[str] = None,
         language: Optional[str] = None,
+        timeout: Optional[float] = None,
         **kwargs
     ) -> TranscribeResponse:
         """
@@ -469,6 +569,7 @@ class BaseLivellmClient(ABC):
             file: The audio file as a tuple (filename, content, content_type)
             model: The model to use for transcription
             language: Optional language code
+            timeout: Optional timeout in seconds (overrides default client timeout)
             gen_config: Optional generation configuration
             
         Returns:
@@ -481,7 +582,7 @@ class BaseLivellmClient(ABC):
                     f"First positional argument must be TranscribeRequest or TranscribeFallbackRequest, got {type(request)}"
                 )
             # JSON-based request
-            return await self.handle_transcribe(request)
+            return await self.handle_transcribe(request, timeout=timeout)
             
         # Otherwise, use keyword arguments with multipart form-data request
         if provider_uid is None or file is None or model is None:
@@ -497,7 +598,7 @@ class BaseLivellmClient(ABC):
             language=language,
             gen_config=kwargs or None
         )
-        return await self.handle_transcribe(transcribe_request)
+        return await self.handle_transcribe(transcribe_request, timeout=timeout)
 
 
 class LivellmWsClient(BaseLivellmClient):
@@ -505,7 +606,8 @@ class LivellmWsClient(BaseLivellmClient):
 
     def __init__(
         self, 
-        base_url: str, 
+        base_url: str,
+        user_agent: Optional[str] = None,
         timeout: Optional[float] = None,
         max_size: Optional[int] = None,
         max_buffer_size: Optional[int] = None
@@ -523,6 +625,7 @@ class LivellmWsClient(BaseLivellmClient):
         self._ws_root_base_url = ws_url
         self.base_url = f"{ws_url}/livellm/ws"
         self.timeout = timeout
+        self.user_agent = user_agent or DEFAULT_USER_AGENT
         self.websocket = None
         self.sessions: Dict[str, asyncio.Queue] = {}
         self.max_buffer_size = max_buffer_size or 0 # None means unlimited buffer size
@@ -541,7 +644,8 @@ class LivellmWsClient(BaseLivellmClient):
             self.base_url, 
             open_timeout=self.timeout,
             close_timeout=self.timeout,
-            max_size=self.max_size
+            max_size=self.max_size,
+            additional_headers={"User-Agent": self.user_agent}
         )
         self.__listen_for_responses_task = asyncio.create_task(self.listen_for_responses())
                 
@@ -572,7 +676,11 @@ class LivellmWsClient(BaseLivellmClient):
             self.__listen_for_responses_task = None
         self.sessions.clear()
     
-    async def get_response(self, action: WsAction, payload: dict) -> dict:
+    def _get_effective_timeout(self, timeout: Optional[float]) -> Optional[float]:
+        """Get effective timeout: per-request timeout overrides default."""
+        return timeout if timeout is not None else self.timeout
+    
+    async def get_response(self, action: WsAction, payload: dict, timeout: Optional[float] = None) -> dict:
         """Send a request and wait for response."""
         if self.websocket is None:
             await self.connect()
@@ -582,7 +690,17 @@ class LivellmWsClient(BaseLivellmClient):
         q = await self.get_or_update_session(session_id)
         await self.websocket.send(json.dumps(request.model_dump()))
         
-        response: WsResponse = await q.get()
+        effective_timeout = self._get_effective_timeout(timeout)
+        
+        try:
+            if effective_timeout:
+                response: WsResponse = await asyncio.wait_for(q.get(), timeout=effective_timeout)
+            else:
+                response: WsResponse = await q.get()
+        except asyncio.TimeoutError:
+            self.sessions.pop(session_id, None)
+            raise TimeoutError(f"Request timed out after {effective_timeout} seconds")
+        
         self.sessions.pop(session_id)
         if response.status == WsStatus.ERROR:
             raise Exception(f"WebSocket failed: {response.error}")
@@ -591,7 +709,7 @@ class LivellmWsClient(BaseLivellmClient):
         else:
             raise Exception(f"WebSocket failed with unknown status: {response}")
     
-    async def get_response_stream(self, action: WsAction, payload: dict) -> AsyncIterator[dict]:
+    async def get_response_stream(self, action: WsAction, payload: dict, timeout: Optional[float] = None) -> AsyncIterator[dict]:
         """Send a request and stream responses."""
         if self.websocket is None:
             await self.connect()
@@ -601,8 +719,17 @@ class LivellmWsClient(BaseLivellmClient):
         q = await self.get_or_update_session(session_id)
         await self.websocket.send(json.dumps(request.model_dump()))
         
+        effective_timeout = self._get_effective_timeout(timeout)
+        
         while True:
-            response: WsResponse = await q.get()
+            try:
+                if effective_timeout:
+                    response: WsResponse = await asyncio.wait_for(q.get(), timeout=effective_timeout)
+                else:
+                    response: WsResponse = await q.get()
+            except asyncio.TimeoutError:
+                self.sessions.pop(session_id, None)
+                raise TimeoutError(f"Request timed out after {effective_timeout} seconds")
             
             if response.status == WsStatus.STREAMING:
                 yield response.data
@@ -618,37 +745,60 @@ class LivellmWsClient(BaseLivellmClient):
     
     # Implement abstract methods from BaseLivellmClient
     
-    async def handle_agent_run(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AgentResponse:
+    async def handle_agent_run(
+        self, 
+        request: Union[AgentRequest, AgentFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> AgentResponse:
         """Handle agent run via WebSocket."""
         response = await self.get_response(
             WsAction.AGENT_RUN,
-            request.model_dump()
+            request.model_dump(),
+            timeout=timeout
         )
         return AgentResponse(**response)
     
-    async def handle_agent_run_stream(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AsyncIterator[AgentResponse]:
+    async def handle_agent_run_stream(
+        self, 
+        request: Union[AgentRequest, AgentFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> AsyncIterator[AgentResponse]:
         """Handle streaming agent run via WebSocket."""
-        async for response in self.get_response_stream(WsAction.AGENT_RUN_STREAM, request.model_dump()):
+        async for response in self.get_response_stream(WsAction.AGENT_RUN_STREAM, request.model_dump(), timeout=timeout):
             yield AgentResponse(**response)
     
-    async def handle_speak(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> bytes:
+    async def handle_speak(
+        self, 
+        request: Union[SpeakRequest, AudioFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> bytes:
         """Handle speak request via WebSocket."""
         response = await self.get_response(
             WsAction.AUDIO_SPEAK,
-            request.model_dump()
+            request.model_dump(),
+            timeout=timeout
         )
         return EncodedSpeakResponse(**response).audio
     
-    async def handle_speak_stream(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> AsyncIterator[bytes]:
+    async def handle_speak_stream(
+        self, 
+        request: Union[SpeakRequest, AudioFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> AsyncIterator[bytes]:
         """Handle streaming speak request via WebSocket."""
-        async for response in self.get_response_stream(WsAction.AUDIO_SPEAK_STREAM, request.model_dump()):
+        async for response in self.get_response_stream(WsAction.AUDIO_SPEAK_STREAM, request.model_dump(), timeout=timeout):
             yield EncodedSpeakResponse(**response).audio
     
-    async def handle_transcribe(self, request: Union[TranscribeRequest, TranscribeFallbackRequest]) -> TranscribeResponse:
+    async def handle_transcribe(
+        self, 
+        request: Union[TranscribeRequest, TranscribeFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> TranscribeResponse:
         """Handle transcribe request via WebSocket."""
         response = await self.get_response(
             WsAction.AUDIO_TRANSCRIBE,
-            request.model_dump()
+            request.model_dump(),
+            timeout=timeout
         )
         return TranscribeResponse(**response)
     
@@ -680,7 +830,8 @@ class LivellmClient(BaseLivellmClient):
 
     def __init__(
         self, 
-        base_url: str, 
+        base_url: str,
+        user_agent: Optional[str] = None,
         timeout: Optional[float] = None,
         configs: Optional[List[Settings]] = None
         ):
@@ -689,17 +840,23 @@ class LivellmClient(BaseLivellmClient):
         # 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.user_agent = user_agent or DEFAULT_USER_AGENT
+        # Create client without timeout - we'll pass timeout per-request
+        self.client = httpx.AsyncClient(base_url=self.base_url)
         self.settings = []
         self.headers = {
             "Content-Type": "application/json",
+            "User-Agent": self.user_agent,
         }
         # Lazily-created realtime (WebSocket) client
         self._realtime = None
         if configs:
             self.update_configs_post_init(configs)
 
+    def _get_effective_timeout(self, timeout: Optional[float]) -> Optional[float]:
+        """Get effective timeout: per-request timeout overrides default."""
+        return timeout if timeout is not None else self.timeout
+
     @property
     def realtime(self) -> LivellmWsClient:
         """
@@ -713,7 +870,7 @@ class LivellmClient(BaseLivellmClient):
         """
         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)
+            self._realtime = LivellmWsClient(self._root_base_url, user_agent=self.user_agent, timeout=self.timeout)
         return self._realtime
     
     def update_configs_post_init(self, configs: List[Settings]) -> SuccessResponse:
@@ -730,15 +887,17 @@ class LivellmClient(BaseLivellmClient):
             return SuccessResponse(success=True, message="Configs updated successfully")
         
 
-    async def delete(self, endpoint: str) -> dict:
+    async def delete(self, endpoint: str, timeout: Optional[float] = None) -> dict:
         """
         Delete a resource from the given endpoint and return the response.
         Args:
             endpoint: The endpoint to delete from.
+            timeout: Optional timeout override.
         Returns:
             The response from the endpoint.
         """
-        response = await self.client.delete(endpoint, headers=self.headers)
+        effective_timeout = self._get_effective_timeout(timeout)
+        response = await self.client.delete(endpoint, headers=self.headers, timeout=effective_timeout)
         response.raise_for_status()
         return response.json()
     
@@ -746,7 +905,8 @@ class LivellmClient(BaseLivellmClient):
         self,
         files: dict,
         data: dict,
-        endpoint: str
+        endpoint: str,
+        timeout: Optional[float] = None
     ) -> dict:
         """
         Post a multipart request to the given endpoint and return the response.
@@ -754,27 +914,32 @@ class LivellmClient(BaseLivellmClient):
             files: The files to send in the request.
             data: The data to send in the request.
             endpoint: The endpoint to post to.
+            timeout: Optional timeout override.
         Returns:
             The response from the endpoint.
         """
+        effective_timeout = self._get_effective_timeout(timeout)
         # Don't pass Content-Type header for multipart - httpx will set it automatically
-        response = await self.client.post(endpoint, files=files, data=data)
+        response = await self.client.post(endpoint, files=files, data=data, timeout=effective_timeout)
         response.raise_for_status()
         return response.json()
     
     
     async def get(
         self,
-        endpoint: str
+        endpoint: str,
+        timeout: Optional[float] = None
     ) -> dict:
         """
         Get a request from the given endpoint and return the response.
         Args:
             endpoint: The endpoint to get from.
+            timeout: Optional timeout override.
         Returns:
             The response from the endpoint.
         """
-        response = await self.client.get(endpoint, headers=self.headers)
+        effective_timeout = self._get_effective_timeout(timeout)
+        response = await self.client.get(endpoint, headers=self.headers, timeout=effective_timeout)
         response.raise_for_status()
         return response.json()
     
@@ -783,7 +948,8 @@ class LivellmClient(BaseLivellmClient):
         json_data: dict, 
         endpoint: str, 
         expect_stream: bool = False, 
-        expect_json: bool = True
+        expect_json: bool = True,
+        timeout: Optional[float] = None
     ) -> Union[dict, bytes, AsyncIterator[Union[dict, bytes]]]:
         """
         Post a request to the given endpoint and return the response.
@@ -795,12 +961,14 @@ class LivellmClient(BaseLivellmClient):
             endpoint: The endpoint to post to.
             expect_stream: Whether to expect a stream response.
             expect_json: Whether to expect a JSON response.
+            timeout: Optional timeout override.
         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)
+        effective_timeout = self._get_effective_timeout(timeout)
+        response = await self.client.post(endpoint, json=json_data, headers=self.headers, timeout=effective_timeout)
         if response.status_code not in [200, 201]:
             error_response = await response.aread()
             error_response = error_response.decode("utf-8")
@@ -823,26 +991,26 @@ class LivellmClient(BaseLivellmClient):
             else:
                 return response.content
     
-    async def ping(self) -> SuccessResponse:
-        result = await self.get("ping")
+    async def ping(self, timeout: Optional[float] = None) -> SuccessResponse:
+        result = await self.get("ping", timeout=timeout)
         return SuccessResponse(**result)
     
-    async def update_config(self, config: Settings) -> SuccessResponse:
-        result = await self.post(config.model_dump(), "providers/config", expect_json=True)
+    async def update_config(self, config: Settings, timeout: Optional[float] = None) -> SuccessResponse:
+        result = await self.post(config.model_dump(), "providers/config", expect_json=True, timeout=timeout)
         self.settings.append(config)
         return SuccessResponse(**result)
     
-    async def update_configs(self, configs: List[Settings]) -> SuccessResponse:
+    async def update_configs(self, configs: List[Settings], timeout: Optional[float] = None) -> SuccessResponse:
         for config in configs:
-            await self.update_config(config)
+            await self.update_config(config, timeout=timeout)
         return SuccessResponse(success=True, message="Configs updated successfully")
     
-    async def get_configs(self) -> List[Settings]:
-        result = await self.get("providers/configs")
+    async def get_configs(self, timeout: Optional[float] = None) -> List[Settings]:
+        result = await self.get("providers/configs", timeout=timeout)
         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}")
+    async def delete_config(self, config_uid: str, timeout: Optional[float] = None) -> SuccessResponse:
+        result = await self.delete(f"providers/config/{config_uid}", timeout=timeout)
         return SuccessResponse(**result)
     
     async def cleanup(self):
@@ -857,59 +1025,51 @@ class LivellmClient(BaseLivellmClient):
         # 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(f"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:
+    async def handle_agent_run(
+        self, 
+        request: Union[AgentRequest, AgentFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> AgentResponse:
         """Handle agent run via HTTP."""
-        result = await self.post(request.model_dump(), "agent/run", expect_json=True)
+        result = await self.post(request.model_dump(), "agent/run", expect_json=True, timeout=timeout)
         return AgentResponse(**result)
     
-    async def handle_agent_run_stream(self, request: Union[AgentRequest, AgentFallbackRequest]) -> AsyncIterator[AgentResponse]:
+    async def handle_agent_run_stream(
+        self, 
+        request: Union[AgentRequest, AgentFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> AsyncIterator[AgentResponse]:
         """Handle streaming agent run via HTTP."""
-        stream = await self.post(request.model_dump(), "agent/run_stream", expect_stream=True, expect_json=True)
+        stream = await self.post(request.model_dump(), "agent/run_stream", expect_stream=True, expect_json=True, timeout=timeout)
         async for chunk in stream:
             yield AgentResponse(**chunk)
     
-    async def handle_speak(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> bytes:
+    async def handle_speak(
+        self, 
+        request: Union[SpeakRequest, AudioFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> bytes:
         """Handle speak request via HTTP."""
-        return await self.post(request.model_dump(), "audio/speak", expect_json=False)
+        return await self.post(request.model_dump(), "audio/speak", expect_json=False, timeout=timeout)
     
-    async def handle_speak_stream(self, request: Union[SpeakRequest, AudioFallbackRequest]) -> AsyncIterator[bytes]:
+    async def handle_speak_stream(
+        self, 
+        request: Union[SpeakRequest, AudioFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> 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)
+        speak_stream = await self.post(request.model_dump(), "audio/speak_stream", expect_stream=True, expect_json=False, timeout=timeout)
         async for chunk in speak_stream:
             yield chunk
     
-    async def handle_transcribe(self, request: Union[TranscribeRequest, TranscribeFallbackRequest]) -> TranscribeResponse:
+    async def handle_transcribe(
+        self, 
+        request: Union[TranscribeRequest, TranscribeFallbackRequest],
+        timeout: Optional[float] = None
+    ) -> TranscribeResponse:
         """Handle transcribe request via HTTP."""
-        result = await self.post(request.model_dump(), "audio/transcribe_json", expect_json=True)
+        result = await self.post(request.model_dump(), "audio/transcribe_json", expect_json=True, timeout=timeout)
         return TranscribeResponse(**result)
-