livellm 1.1.0__py3-none-any.whl

livellm/__init__.py

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

livellm/livellm.py

@@ -0,0 +1,236 @@
+"""LiveLLM Client - Python client for the LiveLLM Proxy and Realtime APIs."""
+import httpx
+import json
+from typing import List, Optional, AsyncIterator, Union
+from .models.common import Settings, SuccessResponse
+from .models.agent.agent import AgentRequest, AgentResponse
+from .models.audio.speak import SpeakRequest
+from .models.audio.transcribe import TranscribeRequest, TranscribeResponse, File
+from .models.fallback import AgentFallbackRequest, AudioFallbackRequest, TranscribeFallbackRequest
+
+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 stream_response() -> AsyncIterator[Union[dict, bytes]]:
+                async for chunk in response.aiter_lines():
+                    if expect_json:
+                        chunk = chunk.strip()
+                        if not chunk:
+                            continue
+                        yield json.loads(chunk)
+                    else:
+                        yield chunk
+            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:
+            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()
+    
+
+    async def agent_run(
+        self,
+        request: Union[AgentRequest, AgentFallbackRequest]
+    ) -> AgentResponse:
+        result = await self.post(request.model_dump(), "agent/run", expect_json=True)
+        return AgentResponse(**result)
+    
+    async def agent_run_stream(
+        self,
+        request: Union[AgentRequest, AgentFallbackRequest]
+    ) -> AsyncIterator[AgentResponse]:
+        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 speak(
+        self,
+        request: Union[SpeakRequest, AudioFallbackRequest]
+    ) -> bytes:
+        return await self.post(request.model_dump(), "audio/speak", expect_json=False)
+    
+    async def speak_stream(
+        self,
+        request: Union[SpeakRequest, AudioFallbackRequest]
+    ) -> AsyncIterator[bytes]:
+        return await self.post(request.model_dump(), "audio/speak_stream", expect_stream=True, expect_json=False)
+    
+
+    async def transcribe(
+        self,
+        provider_uid: str,
+        file: File,
+        model: str,
+        language: Optional[str] = None,
+        gen_config: Optional[dict] = None
+    ) -> TranscribeResponse:
+        files = {
+            "file": file
+        }
+        data = {
+            "provider_uid": provider_uid,
+            "model": model,
+            "language": language,
+            "gen_config": json.dumps(gen_config) if gen_config else None
+        }
+        result = await self.post_multipart(files, data, "audio/transcribe")
+        return TranscribeResponse(**result)
+    
+    async def transcribe_json(
+        self,
+        request: Union[TranscribeRequest, TranscribeFallbackRequest]
+    ) -> TranscribeResponse:
+        result = await self.post(request.model_dump(), "audio/transcribe_json", expect_json=True)
+        return TranscribeResponse(**result)
+         
+
+        
+

livellm/models/__init__.py

@@ -0,0 +1,41 @@
+from .common import BaseRequest, ProviderKind, Settings, SuccessResponse
+from .fallback import AgentFallbackRequest, AudioFallbackRequest, TranscribeFallbackRequest, FallbackStrategy
+from .agent.agent import AgentRequest, AgentResponse, AgentResponseUsage
+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
+
+
+__all__ = [
+    # Common
+    "BaseRequest",
+    "ProviderKind",
+    "Settings",
+    "SuccessResponse",
+    # Fallback
+    "AgentFallbackRequest",
+    "AudioFallbackRequest",
+    "TranscribeFallbackRequest",
+    "FallbackStrategy",
+    # Agent
+    "AgentRequest",
+    "AgentResponse",
+    "AgentResponseUsage",
+    "Message",
+    "MessageRole",
+    "TextMessage",
+    "BinaryMessage",
+    "Tool",
+    "ToolInput",
+    "ToolKind",
+    "WebSearchInput",
+    "MCPStreamableServerInput",
+    # Audio
+    "SpeakMimeType",
+    "SpeakRequest",
+    "SpeakStreamResponse",
+    "TranscribeRequest",
+    "TranscribeResponse",
+    "File",
+]

livellm/models/agent/__init__.py

@@ -0,0 +1,19 @@
+from .agent import AgentRequest, AgentResponse, AgentResponseUsage
+from .chat import Message, MessageRole, TextMessage, BinaryMessage
+from .tools import Tool, ToolInput, ToolKind, WebSearchInput, MCPStreamableServerInput
+
+
+__all__ = [
+    "AgentRequest",
+    "AgentResponse",
+    "AgentResponseUsage",
+    "Message",
+    "MessageRole",
+    "TextMessage",
+    "BinaryMessage",
+    "Tool",
+    "ToolInput",
+    "ToolKind",
+    "WebSearchInput",
+    "MCPStreamableServerInput",
+]

livellm/models/agent/agent.py

@@ -0,0 +1,23 @@
+# models for full run: AgentRequest, AgentResponse
+
+from pydantic import BaseModel, Field
+from typing import Optional, List, Union
+from .chat import TextMessage, BinaryMessage
+from .tools import WebSearchInput, MCPStreamableServerInput
+from ..common import BaseRequest
+
+
+class AgentRequest(BaseRequest):
+    model: str = Field(..., description="The model to use")
+    messages: List[Union[TextMessage, BinaryMessage]]
+    tools: List[Union[WebSearchInput, MCPStreamableServerInput]]
+    gen_config: Optional[dict] = Field(default=None, description="The configuration for the generation")
+
+
+class AgentResponseUsage(BaseModel):
+    input_tokens: int = Field(..., description="The number of input tokens used")
+    output_tokens: int = Field(..., description="The number of output tokens used")
+
+class AgentResponse(BaseModel):
+    output: str = Field(..., description="The output of the response")
+    usage: AgentResponseUsage = Field(..., description="The usage of the response")

livellm/models/agent/chat.py

@@ -0,0 +1,30 @@
+# models for chat messages
+from pydantic import BaseModel, Field, model_validator
+from enum import Enum
+from typing import Optional
+
+class MessageRole(Enum):
+    USER = "user"
+    MODEL = "model"
+    SYSTEM = "system"
+
+
+class Message(BaseModel):
+    role: MessageRole = Field(..., description="The role of the message")
+
+
+class TextMessage(Message):
+    content: str = Field(..., description="The content of the message")
+
+class BinaryMessage(Message):
+    """always from user"""
+    content: str = Field(..., description="The base64 encoded content of the message")
+    mime_type: str = Field(..., description="The MIME type of the content, only user can supply such")
+    caption: Optional[str] = Field(None, description="Caption for the binary message")
+
+    @model_validator(mode="after")
+    def validate_content(self) -> "BinaryMessage":
+        if self.role == MessageRole.MODEL:
+            raise ValueError("MIME type are meant for user messages only")
+        return self
+

livellm/models/agent/tools.py

@@ -0,0 +1,39 @@
+# models for tools
+from pydantic import BaseModel, Field, field_validator
+from typing import Literal
+from enum import Enum
+
+class ToolKind(Enum):
+    WEB_SEARCH = "web_search"
+    MCP_STREAMABLE_SERVER = "mcp_streamable_server"
+
+class Tool(BaseModel):
+    kind: ToolKind
+    input: BaseModel
+
+
+class ToolInput(BaseModel):
+    kind: ToolKind
+    kwargs: dict = Field(default_factory=dict, description="Additional keyword arguments for the MCP server")
+
+class WebSearchInput(ToolInput):
+    kind: ToolKind = Field(ToolKind.WEB_SEARCH, description="Web search kind of tool")
+    search_context_size: Literal['low', 'medium', 'high'] = Field('medium', description="The context size for the search")
+
+    @field_validator('kind')
+    def validate_kind(cls, v):
+        if v != ToolKind.WEB_SEARCH:
+            raise ValueError(f"Invalid kind: {v}")
+        return v
+
+class MCPStreamableServerInput(ToolInput):
+    kind: ToolKind = Field(ToolKind.MCP_STREAMABLE_SERVER, description="Mcp kind of tool")
+    url: str = Field(..., description="The URL of the MCP server")
+    prefix: str = Field(..., description="The prefix of the MCP server")
+    timeout: int = Field(15, description="The timeout in seconds for the MCP server")
+
+    @field_validator('kind')
+    def validate_kind(cls, v):
+        if v != ToolKind.MCP_STREAMABLE_SERVER:
+            raise ValueError(f"Invalid kind: {v}")
+        return v

livellm/models/audio/__init__.py

@@ -0,0 +1,12 @@
+from .speak import SpeakMimeType, SpeakRequest, SpeakStreamResponse
+from .transcribe import TranscribeRequest, TranscribeResponse, File
+
+
+__all__ = [
+    "SpeakMimeType",
+    "SpeakRequest",
+    "SpeakStreamResponse",
+    "TranscribeRequest",
+    "TranscribeResponse",
+    "File",
+]

livellm/models/audio/speak.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel, Field, field_validator
+from typing import Optional, TypeAlias, Tuple, AsyncIterator
+from enum import Enum
+from ..common import BaseRequest
+
+SpeakStreamResponse: TypeAlias = Tuple[AsyncIterator[bytes], str, int]
+
+
+class SpeakMimeType(Enum):
+    PCM = "audio/pcm"
+    WAV = "audio/wav"
+    MP3 = "audio/mpeg"
+    ULAW = "audio/ulaw"
+    ALAW = "audio/alaw"
+
+class SpeakRequest(BaseRequest):
+    model: str = Field(..., description="The model to use")
+    text: str = Field(..., description="The text to speak")
+    voice: str = Field(..., description="The voice to use")
+    mime_type: SpeakMimeType = Field(..., description="The MIME type of the output audio")
+    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")

livellm/models/audio/transcribe.py

@@ -0,0 +1,48 @@
+from pydantic import BaseModel, Field, field_validator
+from typing import Tuple, TypeAlias, Optional, Union
+from ..common import BaseRequest
+import base64
+
+File: TypeAlias = Tuple[str, Union[bytes, str], str] # (filename, file_content, content_type)
+
+class TranscribeRequest(BaseRequest):
+    model: str = Field(..., description="The model to use")
+    file: File = Field(..., description="The file to transcribe")
+    language: Optional[str] = Field(default=None, description="The language to transcribe")
+    gen_config: Optional[dict] = Field(default=None, description="The configuration for the generation")
+    
+    @field_validator('file', mode='before')
+    @classmethod
+    def decode_base64_file(cls, v) -> File:
+        """
+        Validates and processes the file field.
+        
+        Accepts two formats:
+        1. Tuple[str, bytes, str] - Direct bytes (from multipart/form-data)
+        2. Tuple[str, str, str] - Base64 encoded string (from JSON)
+        
+        Returns: Tuple[str, bytes, str] with decoded bytes
+        """
+        if not isinstance(v, (tuple, list)) or len(v) != 3:
+            raise ValueError("file must be a tuple/list of 3 elements: (filename, content, content_type)")
+        
+        filename, content, content_type = v
+        
+        # If content is already bytes, return as-is
+        if isinstance(content, bytes):
+            return (filename, content, content_type)
+        
+        # If content is a string, assume it's base64 encoded
+        elif isinstance(content, str):
+            try:
+                decoded_content = base64.b64decode(content)
+                return (filename, decoded_content, content_type)
+            except Exception as e:
+                raise ValueError(f"Failed to decode base64 content: {str(e)}")
+        else:
+            raise ValueError(f"file content must be either bytes or base64 string, got {type(content)}")
+
+
+class TranscribeResponse(BaseModel):
+    text: str = Field(..., description="The text of the transcription")
+    language: Optional[str] = Field(default=None, description="The language of the transcription")

livellm/models/common.py

@@ -0,0 +1,46 @@
+"""Common models shared across all services"""
+
+from pydantic import BaseModel, Field, SecretStr, model_serializer
+from enum import Enum
+from typing import Optional, Any
+
+
+class BaseRequest(BaseModel):
+    """Base request model that all service requests inherit from"""
+    provider_uid: str = Field(..., description="The unique identifier of the provider configuration to use")
+
+
+class ProviderKind(Enum):
+    """Unified provider types for both agent and audio services"""
+    # Agent providers
+    OPENAI = "openai"
+    GOOGLE = "google"
+    ANTHROPIC = "anthropic"
+    GROQ = "groq"
+    # Audio providers
+    ELEVENLABS = "elevenlabs"
+
+
+class Settings(BaseModel):
+    """Base settings for all service providers"""
+    uid: str = Field(..., description="The unique identifier of the provider configuration")
+    provider: ProviderKind = Field(..., description="The provider to use")
+    api_key: SecretStr = Field(..., description="API key for the provider")
+    base_url: Optional[str] = Field(None, description="Optional custom base URL for the provider")
+    blacklist_models: Optional[list[str]] = Field(None, description="models selection for blacklist")
+
+    @model_serializer
+    def serialize_model(self) -> dict[str, Any]:
+        """Custom serializer to handle SecretStr properly"""
+        return {
+            "uid": self.uid,
+            "provider": self.provider.value,
+            "api_key": self.api_key.get_secret_value(),
+            "base_url": self.base_url,
+            "blacklist_models": self.blacklist_models,
+        }
+
+
+class SuccessResponse(BaseModel):
+    success: bool = Field(True, description="Whether the operation was successful")
+    message: str = Field("ok", description="The message of the operation")

livellm/models/fallback.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+from typing import List
+from .common import BaseRequest
+from .audio.speak import SpeakRequest
+from .audio.transcribe import TranscribeRequest
+from .agent.agent import AgentRequest
+from enum import Enum
+
+class FallbackStrategy(Enum):
+    SEQUENTIAL = "sequential"
+    PARALLEL = "parallel"
+    
+class FallbackRequest(BaseModel):
+    requests: List[BaseRequest] = Field(..., description="List of requests to try as fallbacks")
+    strategy: FallbackStrategy = Field(FallbackStrategy.SEQUENTIAL, description="The strategy to use for fallback")
+    timeout_per_request: int = Field(default=360, description="The timeout to use for each request")
+
+class AgentFallbackRequest(FallbackRequest):
+    requests: List[AgentRequest] = Field(..., description="List of agent requests to try as fallbacks")
+
+class AudioFallbackRequest(FallbackRequest):
+    requests: List[SpeakRequest] = Field(..., description="List of audio requests to try as fallbacks")
+
+class TranscribeFallbackRequest(FallbackRequest):
+    requests: List[TranscribeRequest] = Field(..., description="List of transcribe requests to try as fallbacks")

livellm-1.1.0.dist-info/METADATA

@@ -0,0 +1,573 @@
+Metadata-Version: 2.4
+Name: livellm
+Version: 1.1.0
+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
+Author: Kamil Saliamov
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: testing
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'testing'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'testing'
+Requires-Dist: pytest>=8.4.2; extra == 'testing'
+Description-Content-Type: text/markdown
+
+# LiveLLM Python Client
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Python client library for the LiveLLM Server - a unified proxy for AI agent, audio, and transcription services.
+
+## Features
+
+- 🚀 **Async-first design** - Built on httpx for high-performance async operations
+- 🔒 **Type-safe** - Full type hints and Pydantic validation
+- 🎯 **Multi-provider support** - OpenAI, Google, Anthropic, Groq, ElevenLabs
+- 🔄 **Streaming support** - Real-time streaming for agent and audio responses
+- 🛠️ **Agent tools** - Web search and MCP server integration
+- 🎙️ **Audio services** - Text-to-speech and transcription
+- ⚡ **Fallback strategies** - Sequential and parallel fallback handling
+- 📦 **Context manager support** - Automatic cleanup with async context managers
+
+## Installation
+
+```bash
+pip install livellm-client
+```
+
+Or with development dependencies:
+
+```bash
+pip install livellm-client[testing]
+```
+
+## Quick Start
+
+```python
+import asyncio
+from livellm import LivellmClient
+from livellm.models import Settings, ProviderKind, AgentRequest, TextMessage, MessageRole
+from pydantic import SecretStr
+
+async def main():
+    # Initialize the client with context manager for automatic cleanup
+    async with LivellmClient(base_url="http://localhost:8000") as client:
+        # Configure a provider
+        config = Settings(
+            uid="my-openai-config",
+            provider=ProviderKind.OPENAI,
+            api_key=SecretStr("your-api-key")
+        )
+        await client.update_config(config)
+        
+        # Run an agent query
+        request = AgentRequest(
+            provider_uid="my-openai-config",
+            model="gpt-4",
+            messages=[
+                TextMessage(role=MessageRole.USER, content="Hello, how are you?")
+            ],
+            tools=[]
+        )
+        
+        response = await client.agent_run(request)
+        print(response.output)
+
+asyncio.run(main())
+```
+
+## Configuration
+
+### Client Initialization
+
+```python
+from livellm import LivellmClient
+
+# Basic initialization
+client = LivellmClient(base_url="http://localhost:8000")
+
+# With timeout
+client = LivellmClient(
+    base_url="http://localhost:8000",
+    timeout=30.0
+)
+
+# With pre-configured providers (sync operation)
+from livellm.models import Settings, ProviderKind
+from pydantic import SecretStr
+
+configs = [
+    Settings(
+        uid="openai-config",
+        provider=ProviderKind.OPENAI,
+        api_key=SecretStr("sk-..."),
+        base_url="https://api.openai.com/v1"  # Optional custom base URL
+    ),
+    Settings(
+        uid="anthropic-config",
+        provider=ProviderKind.ANTHROPIC,
+        api_key=SecretStr("sk-ant-..."),
+        blacklist_models=["claude-instant-1"]  # Optional model blacklist
+    )
+]
+
+client = LivellmClient(
+    base_url="http://localhost:8000",
+    configs=configs
+)
+```
+
+### Provider Configuration
+
+Supported providers:
+- `OPENAI` - OpenAI GPT models
+- `GOOGLE` - Google Gemini models
+- `ANTHROPIC` - Anthropic Claude models
+- `GROQ` - Groq models
+- `ELEVENLABS` - ElevenLabs text-to-speech
+
+```python
+# Add a provider configuration
+config = Settings(
+    uid="unique-provider-id",
+    provider=ProviderKind.OPENAI,
+    api_key=SecretStr("your-api-key"),
+    base_url="https://custom-endpoint.com",  # Optional
+    blacklist_models=["deprecated-model"]     # Optional
+)
+await client.update_config(config)
+
+# Get all configurations
+configs = await client.get_configs()
+
+# Delete a configuration
+await client.delete_config("unique-provider-id")
+```
+
+## Usage Examples
+
+### Agent Services
+
+#### Basic Agent Run
+
+```python
+from livellm.models import AgentRequest, TextMessage, MessageRole
+
+request = AgentRequest(
+    provider_uid="my-openai-config",
+    model="gpt-4",
+    messages=[
+        TextMessage(role=MessageRole.SYSTEM, content="You are a helpful assistant."),
+        TextMessage(role=MessageRole.USER, content="Explain quantum computing")
+    ],
+    tools=[],
+    gen_config={"temperature": 0.7, "max_tokens": 500}
+)
+
+response = await client.agent_run(request)
+print(f"Output: {response.output}")
+print(f"Tokens used - Input: {response.usage.input_tokens}, Output: {response.usage.output_tokens}")
+```
+
+#### Streaming Agent Response
+
+```python
+request = AgentRequest(
+    provider_uid="my-openai-config",
+    model="gpt-4",
+    messages=[
+        TextMessage(role=MessageRole.USER, content="Tell me a story")
+    ],
+    tools=[]
+)
+
+stream = await client.agent_run_stream(request)
+async for chunk in stream:
+    print(chunk.output, end="", flush=True)
+```
+
+#### Agent with Binary Messages
+
+```python
+import base64
+
+# Read and encode image
+with open("image.jpg", "rb") as f:
+    image_data = base64.b64encode(f.read()).decode("utf-8")
+
+from livellm.models import BinaryMessage
+
+request = AgentRequest(
+    provider_uid="my-openai-config",
+    model="gpt-4-vision",
+    messages=[
+        BinaryMessage(
+            role=MessageRole.USER,
+            content=image_data,
+            mime_type="image/jpeg",
+            caption="What's in this image?"
+        )
+    ],
+    tools=[]
+)
+
+response = await client.agent_run(request)
+```
+
+#### Agent with Web Search Tool
+
+```python
+from livellm.models import WebSearchInput, ToolKind
+
+request = AgentRequest(
+    provider_uid="my-openai-config",
+    model="gpt-4",
+    messages=[
+        TextMessage(role=MessageRole.USER, content="What's the latest news about AI?")
+    ],
+    tools=[
+        WebSearchInput(
+            kind=ToolKind.WEB_SEARCH,
+            search_context_size="high"  # Options: "low", "medium", "high"
+        )
+    ]
+)
+
+response = await client.agent_run(request)
+```
+
+#### Agent with MCP Server Tool
+
+```python
+from livellm.models import MCPStreamableServerInput, ToolKind
+
+request = AgentRequest(
+    provider_uid="my-openai-config",
+    model="gpt-4",
+    messages=[
+        TextMessage(role=MessageRole.USER, content="Execute tool")
+    ],
+    tools=[
+        MCPStreamableServerInput(
+            kind=ToolKind.MCP_STREAMABLE_SERVER,
+            url="http://mcp-server:8080",
+            prefix="mcp_",
+            timeout=15,
+            kwargs={"custom_param": "value"}
+        )
+    ]
+)
+
+response = await client.agent_run(request)
+```
+
+### Audio Services
+
+#### Text-to-Speech
+
+```python
+from livellm.models import SpeakRequest, SpeakMimeType
+
+request = SpeakRequest(
+    provider_uid="elevenlabs-config",
+    model="eleven_turbo_v2",
+    text="Hello, this is a test of text to speech.",
+    voice="rachel",
+    mime_type=SpeakMimeType.MP3,
+    sample_rate=44100,
+    gen_config={"stability": 0.5, "similarity_boost": 0.75}
+)
+
+# Get audio as bytes
+audio_bytes = await client.speak(request)
+with open("output.mp3", "wb") as f:
+    f.write(audio_bytes)
+```
+
+#### Streaming Text-to-Speech
+
+```python
+request = SpeakRequest(
+    provider_uid="elevenlabs-config",
+    model="eleven_turbo_v2",
+    text="This is a longer text that will be streamed.",
+    voice="rachel",
+    mime_type=SpeakMimeType.MP3,
+    sample_rate=44100,
+    chunk_size=20  # Chunk size in milliseconds
+)
+
+# Stream audio chunks
+stream = await client.speak_stream(request)
+with open("output.mp3", "wb") as f:
+    async for chunk in stream:
+        f.write(chunk)
+```
+
+#### Audio Transcription (Multipart)
+
+```python
+# Using multipart upload
+with open("audio.mp3", "rb") as f:
+    file_tuple = ("audio.mp3", f.read(), "audio/mpeg")
+
+response = await client.transcribe(
+    provider_uid="openai-config",
+    file=file_tuple,
+    model="whisper-1",
+    language="en",
+    gen_config={"temperature": 0.2}
+)
+
+print(f"Transcription: {response.text}")
+print(f"Detected language: {response.language}")
+```
+
+#### Audio Transcription (JSON)
+
+```python
+import base64
+from livellm.models import TranscribeRequest
+
+with open("audio.mp3", "rb") as f:
+    audio_data = base64.b64encode(f.read()).decode("utf-8")
+
+request = TranscribeRequest(
+    provider_uid="openai-config",
+    model="whisper-1",
+    file=("audio.mp3", audio_data, "audio/mpeg"),
+    language="en"
+)
+
+response = await client.transcribe_json(request)
+```
+
+### Fallback Strategies
+
+#### Sequential Fallback (Try each provider in order)
+
+```python
+from livellm.models import AgentFallbackRequest, FallbackStrategy
+
+fallback_request = AgentFallbackRequest(
+    requests=[
+        AgentRequest(
+            provider_uid="primary-provider",
+            model="gpt-4",
+            messages=[TextMessage(role=MessageRole.USER, content="Hello")],
+            tools=[]
+        ),
+        AgentRequest(
+            provider_uid="backup-provider",
+            model="claude-3",
+            messages=[TextMessage(role=MessageRole.USER, content="Hello")],
+            tools=[]
+        )
+    ],
+    strategy=FallbackStrategy.SEQUENTIAL,
+    timeout_per_request=30
+)
+
+response = await client.agent_run(fallback_request)
+```
+
+#### Parallel Fallback (Try all providers simultaneously)
+
+```python
+fallback_request = AgentFallbackRequest(
+    requests=[
+        AgentRequest(provider_uid="provider-1", model="gpt-4", messages=messages, tools=[]),
+        AgentRequest(provider_uid="provider-2", model="claude-3", messages=messages, tools=[]),
+        AgentRequest(provider_uid="provider-3", model="gemini-pro", messages=messages, tools=[])
+    ],
+    strategy=FallbackStrategy.PARALLEL,
+    timeout_per_request=10
+)
+
+response = await client.agent_run(fallback_request)
+```
+
+#### Audio Fallback
+
+```python
+from livellm.models import AudioFallbackRequest
+
+fallback_request = AudioFallbackRequest(
+    requests=[
+        SpeakRequest(provider_uid="elevenlabs", model="model-1", text=text, voice="voice1", 
+                     mime_type=SpeakMimeType.MP3, sample_rate=44100),
+        SpeakRequest(provider_uid="openai", model="tts-1", text=text, voice="alloy",
+                     mime_type=SpeakMimeType.MP3, sample_rate=44100)
+    ],
+    strategy=FallbackStrategy.SEQUENTIAL
+)
+
+audio = await client.speak(fallback_request)
+```
+
+## Context Manager Support
+
+The client supports async context managers for automatic cleanup:
+
+```python
+async with LivellmClient(base_url="http://localhost:8000") as client:
+    config = Settings(uid="temp-config", provider=ProviderKind.OPENAI, 
+                      api_key=SecretStr("key"))
+    await client.update_config(config)
+    
+    # Use client...
+    response = await client.ping()
+    
+# Automatically cleans up configs and closes HTTP client
+```
+
+Or manually:
+
+```python
+client = LivellmClient(base_url="http://localhost:8000")
+try:
+    # Use client...
+    pass
+finally:
+    await client.cleanup()
+```
+
+## API Reference
+
+### Client Methods
+
+#### Health Check
+- `ping() -> SuccessResponse` - Check server health
+
+#### Configuration Management
+- `update_config(config: Settings) -> SuccessResponse` - Add/update a provider config
+- `update_configs(configs: List[Settings]) -> SuccessResponse` - Add/update multiple configs
+- `get_configs() -> List[Settings]` - Get all provider configurations
+- `delete_config(config_uid: str) -> SuccessResponse` - Delete a provider config
+
+#### Agent Services
+- `agent_run(request: AgentRequest | AgentFallbackRequest) -> AgentResponse` - Run agent query
+- `agent_run_stream(request: AgentRequest | AgentFallbackRequest) -> AsyncIterator[AgentResponse]` - Stream agent response
+
+#### Audio Services
+- `speak(request: SpeakRequest | AudioFallbackRequest) -> bytes` - Text-to-speech
+- `speak_stream(request: SpeakRequest | AudioFallbackRequest) -> AsyncIterator[bytes]` - Streaming TTS
+- `transcribe(provider_uid, file, model, language?, gen_config?) -> TranscribeResponse` - Multipart transcription
+- `transcribe_json(request: TranscribeRequest | TranscribeFallbackRequest) -> TranscribeResponse` - JSON transcription
+
+#### Cleanup
+- `cleanup() -> None` - Clean up resources and close client
+- `__aenter__() / __aexit__()` - Async context manager support
+
+### Models
+
+#### Common Models
+- `Settings` - Provider configuration
+- `ProviderKind` - Enum of supported providers
+- `SuccessResponse` - Generic success response
+- `BaseRequest` - Base class for all requests
+
+#### Agent Models
+- `AgentRequest` - Agent query request
+- `AgentResponse` - Agent query response
+- `AgentResponseUsage` - Token usage information
+- `TextMessage` - Text-based message
+- `BinaryMessage` - Binary message (images, audio, etc.)
+- `MessageRole` - Enum: USER, MODEL, SYSTEM
+
+#### Tool Models
+- `ToolKind` - Enum: WEB_SEARCH, MCP_STREAMABLE_SERVER
+- `WebSearchInput` - Web search tool configuration
+- `MCPStreamableServerInput` - MCP server tool configuration
+
+#### Audio Models
+- `SpeakRequest` - Text-to-speech request
+- `SpeakMimeType` - Enum: PCM, WAV, MP3, ULAW, ALAW
+- `TranscribeRequest` - Transcription request
+- `TranscribeResponse` - Transcription response
+
+#### Fallback Models
+- `FallbackStrategy` - Enum: SEQUENTIAL, PARALLEL
+- `AgentFallbackRequest` - Agent fallback configuration
+- `AudioFallbackRequest` - Audio fallback configuration
+- `TranscribeFallbackRequest` - Transcription fallback configuration
+
+## Error Handling
+
+The client raises exceptions for HTTP errors:
+
+```python
+try:
+    response = await client.agent_run(request)
+except Exception as e:
+    print(f"Error: {e}")
+```
+
+For more granular error handling:
+
+```python
+import httpx
+
+try:
+    response = await client.ping()
+except httpx.HTTPStatusError as e:
+    print(f"HTTP error: {e.response.status_code}")
+except httpx.RequestError as e:
+    print(f"Request error: {e}")
+```
+
+## Development
+
+### Running Tests
+
+```bash
+# Install development dependencies
+pip install -e ".[testing]"
+
+# Run tests
+pytest tests/
+```
+
+### Type Checking
+
+The library is fully typed. Run type checking with:
+
+```bash
+pip install mypy
+mypy livellm
+```
+
+## Requirements
+
+- Python 3.10+
+- httpx >= 0.27.0
+- pydantic >= 2.0.0
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Links
+
+- [GitHub Repository](https://github.com/qalby-tech/livellm-client-py)
+- [Issue Tracker](https://github.com/qalby-tech/livellm-client-py/issues)
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for version history and changes.

livellm-1.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+livellm/__init__.py,sha256=JG_0-UCfQI_3D0Y2PzobZLS5OhJwK76i8t81ye0KpfY,279
+livellm/livellm.py,sha256=0C4LpQy3EOzxNQ6ltIZqStquYuV1WoKcJSFMVtkI4Sk,8635
+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=AybOrNEP_5JwgForVTWGlK39PWvvapjj4UP7sx3e5qU,1144
+livellm/models/agent/__init__.py,sha256=KVm6AgQoWEaoq47QAG4Ou4NimoXOTkjXC-0-gnMRLZ8,476
+livellm/models/agent/agent.py,sha256=2qCh-SsHPhrL7-phv0HpojNgixXg42FhVW8tOv8K7z8,980
+livellm/models/agent/chat.py,sha256=whDuFo8ddR6dPwKo0mMZS7LzCBkL3sVb4lr7tVXjg-M,983
+livellm/models/agent/tools.py,sha256=gHyVUjK6HzXB6Sd64TIM6pLjmTKSGe-fOEH9ELs5dgg,1398
+livellm/models/audio/__init__.py,sha256=sz2NxCOfFGVvp-XQUsdgOR_TYBO1Wb-8LLXaZDEiAZk,282
+livellm/models/audio/speak.py,sha256=4cJhXonImeohL2Fltc2ub_aCGeTAoew6Hnz-myrrR8k,1001
+livellm/models/audio/transcribe.py,sha256=0XtK_f5cYPO4VMD0lh6tYYQQPFaj4g3N2eK7nzuEjKY,2111
+livellm-1.1.0.dist-info/METADATA,sha256=RuCnzRRlAF5VhAmpyalSqhx2aWYrJlSdPWAmt92GFIo,15207
+livellm-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+livellm-1.1.0.dist-info/licenses/LICENSE,sha256=yapGO2C_00ymEx6TADdbU8Oyc1bWOrZY-fjP-agmFL4,1071
+livellm-1.1.0.dist-info/RECORD,,

livellm-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

livellm-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kamil Saliamov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.