litellm-adk 0.1.2__py3-none-any.whl

litellm_adk/__init__.py

@@ -0,0 +1,15 @@
+from .agents import LiteLLMAgent
+from .tools import tool, tool_registry
+from .config.settings import settings
+from .memory import BaseMemory, InMemoryMemory, FileMemory, MongoDBMemory
+
+__all__ = [
+    "LiteLLMAgent", 
+    "tool", 
+    "tool_registry", 
+    "settings", 
+    "BaseMemory", 
+    "InMemoryMemory", 
+    "FileMemory", 
+    "MongoDBMemory"
+]

litellm_adk/agents/__init__.py

@@ -0,0 +1,3 @@
+from ..core.agent import LiteLLMAgent
+
+__all__ = ["LiteLLMAgent"]

litellm_adk/config/settings.py

@@ -0,0 +1,32 @@
+from typing import Optional
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import Field
+
+class Settings(BaseSettings):
+    """
+    Application settings, loaded from environment variables or .env file.
+    """
+    model_config = SettingsConfigDict(
+        env_file=".env", 
+        env_file_encoding="utf-8", 
+        extra="ignore",
+        env_prefix="ADK_"  # Support ADK_ prefixed env vars
+    )
+
+    # Core LLM Settings
+    model: str = Field(default="gpt-4o", description="The model to use.")
+    api_key: Optional[str] = Field(default=None, description="Global API key.")
+    base_url: Optional[str] = Field(default=None, description="Global base URL.")
+    
+    # Provider-specific keys (fallback)
+    openai_api_key: Optional[str] = None
+    anthropic_api_key: Optional[str] = None
+    cohere_api_key: Optional[str] = None
+    
+    # Logging
+    log_level: str = Field(default="INFO", description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)")
+    
+    # Agent Defaults
+    sequential_execution: bool = Field(default=True, description="Default sequential tool execution mode.")
+
+settings = Settings()

litellm_adk/core/agent.py

@@ -0,0 +1,496 @@
+import litellm
+import json
+from typing import List, Dict, Any, Optional, Union, Generator, AsyncGenerator
+from .base import BaseAgent
+from ..observability.logger import adk_logger
+from ..config.settings import settings
+from ..tools.registry import tool_registry
+from ..memory.base import BaseMemory
+from ..memory.in_memory import InMemoryMemory
+import uuid
+
+# Global LiteLLM configuration for resilience
+litellm.drop_params = True
+
+class LiteLLMAgent(BaseAgent):
+    """
+    Agent powered by LiteLLM, supporting dynamic overrides for base_url and api_key.
+    """
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        system_prompt: str = "You are a helpful assistant.",
+        tools: Optional[List[Dict[str, Any]]] = None,
+        memory: Optional[BaseMemory] = None,
+        session_id: Optional[str] = None,
+        **kwargs
+    ):
+        self.model = model or settings.model
+        self.api_key = api_key or settings.api_key
+        self.base_url = base_url or settings.base_url
+        
+        # Automatically prepend 'openai/' if a base_url is used to force proxy/OpenAI-compatible routing
+        if self.base_url and not self.model.startswith("openai/"):
+            adk_logger.debug(f"Custom base_url detected. Prepending 'openai/' to model {self.model}")
+            self.model = f"openai/{self.model}"
+            
+        self.system_prompt = system_prompt
+        
+        # Smart Tool Resolution
+        if tools is None:
+            # Default to all registered tools if none provided
+            self.tools = tool_registry.get_tool_definitions()
+        else:
+            # Process provided list (can be definitions OR functions)
+            processed_tools = []
+            for t in tools:
+                if callable(t):
+                    # It's a function, register it (if not already) and get definition
+                    processed_tools.append(tool_registry._register_function(t))
+                else:
+                    # It's already a definition dict
+                    processed_tools.append(t)
+            self.tools = processed_tools
+
+        self.extra_kwargs = kwargs
+        
+        # Ensure model-specific parameters        # Default parallel_tool_calls if not explicitly provided
+        if "parallel_tool_calls" not in self.extra_kwargs:
+            self.extra_kwargs["parallel_tool_calls"] = False
+            
+        self.sequential_tool_execution = kwargs.get("sequential_tool_execution", settings.sequential_execution)
+        
+        # Memory Persistence
+        self.memory = memory or InMemoryMemory()
+        self.session_id = session_id or str(uuid.uuid4())
+        self.history = self.memory.get_messages(self.session_id)
+        
+        if not self.history:
+            self.history = [{"role": "system", "content": self.system_prompt}]
+            self.memory.add_message(self.session_id, self.history[0])
+            
+        adk_logger.debug(f"Initialized LiteLLMAgent with session_id={self.session_id}, model={self.model}")
+
+    def _prepare_messages(self, prompt: str) -> List[Dict[str, str]]:
+        # Refresh from memory in case it was modified elsewhere
+        self.history = self.memory.get_messages(self.session_id)
+        
+        messages = self.history.copy()
+        user_msg = {"role": "user", "content": prompt}
+        messages.append(user_msg)
+        
+        # Persist the user message immediately
+        self.memory.add_message(self.session_id, user_msg)
+        self.history.append(user_msg)
+        
+        return messages
+
+    def _update_history(self, final_messages: List[Dict[str, Any]]):
+        """Sync internal history and memory with the final message state."""
+        # Find which messages were added since we prepared (the user message was already added)
+        # We assume messages order is preserved
+        start_idx = len(self.history)
+        new_messages = [self._sanitize_message(m) for m in final_messages[start_idx:]]
+        
+        if new_messages:
+            self.memory.add_messages(self.session_id, new_messages)
+            self.history.extend(new_messages)
+
+    def _sanitize_message(self, message: Any) -> Dict[str, Any]:
+        """Convert LiteLLM message objects to plain dictionaries for serialization."""
+        if isinstance(message, dict):
+            # Still need to sanitize tool_calls inside if they are objects
+            if "tool_calls" in message and message["tool_calls"]:
+                message["tool_calls"] = [self._sanitize_tool_call(tc) for tc in message["tool_calls"]]
+            return message
+        
+        # Manually extract common fields to ensure clean JSON
+        msg_dict = {
+            "role": getattr(message, "role", "assistant"),
+            "content": getattr(message, "content", None)
+        }
+        
+        if hasattr(message, "name") and message.name:
+            msg_dict["name"] = message.name
+            
+        if hasattr(message, "tool_calls") and message.tool_calls:
+            msg_dict["tool_calls"] = [self._sanitize_tool_call(tc) for tc in message.tool_calls]
+            
+        if hasattr(message, "tool_call_id") and message.tool_call_id:
+            msg_dict["tool_call_id"] = message.tool_call_id
+            
+        return msg_dict
+
+    def _sanitize_tool_call(self, tc: Any) -> Dict[str, Any]:
+        """Convert a tool call object to a standard dictionary."""
+        if isinstance(tc, dict):
+            return tc
+            
+        tc_dict = {
+            "id": getattr(tc, "id", None),
+            "type": getattr(tc, "type", "function"),
+            "function": {
+                "name": None,
+                "arguments": ""
+            }
+        }
+        
+        func = getattr(tc, "function", None)
+        if func:
+            tc_dict["function"]["name"] = getattr(func, "name", None)
+            tc_dict["function"]["arguments"] = getattr(func, "arguments", "")
+            
+        return tc_dict
+
+    def _should_handle_sequentially(self) -> bool:
+        """Determines if we should process tool calls one by one."""
+        return self.sequential_tool_execution
+
+    async def _aexecute_tool(self, tool_call) -> Any:
+        # Same as _execute_tool but for async if needed in future
+        return self._execute_tool(tool_call)
+
+    def _get_tc_val(self, tool_call, attr, subattr=None):
+        """Helper to get value from either object or dict tool call."""
+        if isinstance(tool_call, dict):
+            val = tool_call.get(attr)
+            if val and subattr:
+                return val.get(subattr)
+            return val
+        else:
+            val = getattr(tool_call, attr, None)
+            if val and subattr:
+                return getattr(val, subattr, None)
+            return val
+
+    def _execute_tool(self, tool_call) -> Any:
+        """Helper to execute a tool call and handle JSON parsing."""
+        function_name = self._get_tc_val(tool_call, "function", "name")
+        raw_args = self._get_tc_val(tool_call, "function", "arguments") or "{}"
+        
+        try:
+            if isinstance(raw_args, dict):
+                arguments = raw_args
+            else:
+                # Try standard parsing
+                arguments = json.loads(raw_args)
+        except json.JSONDecodeError:
+            # RECOVERY: Handle concatenated JSON objects like {"a":1}{"b":2}
+            if isinstance(raw_args, str) and "}{" in raw_args:
+                try:
+                    # Take only the first valid JSON object
+                    decoder = json.JSONDecoder()
+                    arguments, _ = decoder.raw_decode(raw_args)
+                except Exception:
+                    adk_logger.error(f"Failed to recover tool arguments: {raw_args}")
+                    arguments = {}
+            else:
+                adk_logger.warning(f"Failed to parse tool arguments for {function_name}: {raw_args}")
+                arguments = {}
+        
+        return tool_registry.execute(function_name, **arguments)
+
+    def invoke(self, prompt: str, tools: Optional[List[Dict[str, Any]]] = None, **kwargs) -> str:
+        """
+        Execute a synchronous completion with automatic tool calling.
+        """
+        messages = self._prepare_messages(prompt)
+        tools = tools or self.tools
+        
+        adk_logger.info(f"Invoking completion for model: {self.model}")
+        
+        while True:
+            response = litellm.completion(
+                model=self.model,
+                messages=messages,
+                api_key=self.api_key,
+                base_url=self.base_url,
+                tools=tools,
+                **{**self.extra_kwargs, **kwargs}
+            )
+            
+            message = response.choices[0].message
+            
+            # Check if the model wants to call tools
+            if hasattr(message, "tool_calls") and message.tool_calls:
+                # If sequential is enabled, we only process the FIRST tool call
+                tool_calls_to_process = [message.tool_calls[0]] if self._should_handle_sequentially() else message.tool_calls
+                
+                # We update the original message to only include the calls we are handling 
+                # (to keep history clean for strict models)
+                if self._should_handle_sequentially():
+                    message.tool_calls = tool_calls_to_process
+
+                sanitized_msg = self._sanitize_message(message)
+                messages.append(sanitized_msg)
+                
+                for tool_call in tool_calls_to_process:
+                    result = self._execute_tool(tool_call)
+                    
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": tool_call.function.name,
+                        "content": str(result)
+                    })
+                
+                continue
+            
+            messages.append(self._sanitize_message(message))
+            self._update_history(messages)
+            return message.content
+
+    async def ainvoke(self, prompt: str, tools: Optional[List[Dict[str, Any]]] = None, **kwargs) -> str:
+        """
+        Execute an asynchronous completion with automatic tool calling.
+        """
+        messages = self._prepare_messages(prompt)
+        tools = tools or self.tools
+        
+        adk_logger.info(f"Invoking async completion for model: {self.model}")
+        
+        while True:
+            response = await litellm.acompletion(
+                model=self.model,
+                messages=messages,
+                api_key=self.api_key,
+                base_url=self.base_url,
+                tools=tools,
+                **{**self.extra_kwargs, **kwargs}
+            )
+            
+            message = response.choices[0].message
+            
+            if hasattr(message, "tool_calls") and message.tool_calls:
+                tool_calls_to_process = [message.tool_calls[0]] if self._should_handle_sequentially() else message.tool_calls
+                
+                if self._should_handle_sequentially():
+                    message.tool_calls = tool_calls_to_process
+
+                sanitized_msg = self._sanitize_message(message)
+                messages.append(sanitized_msg)
+                
+                for tool_call in tool_calls_to_process:
+                    result = self._execute_tool(tool_call)
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": tool_call.function.name,
+                        "content": str(result)
+                    })
+                continue
+            
+            messages.append(self._sanitize_message(message))
+            self._update_history(messages)
+            return message.content
+
+    def stream(self, prompt: str, tools: Optional[List[Dict[str, Any]]] = None, **kwargs) -> Generator[str, None, None]:
+        """
+        Execute a streaming completion with automatic tool calling.
+        """
+        messages = self._prepare_messages(prompt)
+        tools = tools or self.tools
+        
+        while True:
+            response = litellm.completion(
+                model=self.model,
+                messages=messages,
+                api_key=self.api_key,
+                base_url=self.base_url,
+                stream=True,
+                tools=tools,
+                **{**self.extra_kwargs, **kwargs}
+            )
+            
+            # Accumulate tool call parts
+            full_content = ""
+            tool_calls_by_index = {} # map of index -> list of SimpleNamespace
+            
+            for chunk in response:
+                delta = chunk.choices[0].delta
+                if delta.content:
+                    full_content += delta.content
+                    yield delta.content
+                
+                if hasattr(delta, "tool_calls") and delta.tool_calls:
+                    for tc_delta in delta.tool_calls:
+                        idx = tc_delta.index
+                        if idx not in tool_calls_by_index:
+                            tool_calls_by_index[idx] = []
+                        
+                        last_tc = tool_calls_by_index[idx][-1] if tool_calls_by_index[idx] else None
+                        
+                        # Decide if we need a new tool call object for this index
+                        start_new = False
+                        if last_tc is None:
+                            start_new = True
+                        else:
+                            # Start new if name is present and last one already has a name
+                            if tc_delta.function and tc_delta.function.name and last_tc.function.name:
+                                start_new = True
+                            # Start new if ID is present and last one already has a different ID
+                            elif tc_delta.id and last_tc.id and tc_delta.id != last_tc.id:
+                                start_new = True
+                        
+                        if start_new:
+                            from types import SimpleNamespace
+                            new_tc = SimpleNamespace(
+                                id=tc_delta.id,
+                                function=SimpleNamespace(
+                                    name=tc_delta.function.name if tc_delta.function else None,
+                                    arguments=tc_delta.function.arguments if tc_delta.function else ""
+                                )
+                            )
+                            tool_calls_by_index[idx].append(new_tc)
+                        else:
+                            # Update existing tool call
+                            if tc_delta.id:
+                                last_tc.id = tc_delta.id
+                            if tc_delta.function:
+                                if tc_delta.function.name:
+                                    last_tc.function.name = (last_tc.function.name or "") + tc_delta.function.name
+                                if tc_delta.function.arguments:
+                                    if last_tc.function.arguments is None:
+                                        last_tc.function.arguments = ""
+                                    last_tc.function.arguments += tc_delta.function.arguments
+
+            # Build final flattened tool calls list (as dicts for history)
+            tool_calls = []
+            for idx in sorted(tool_calls_by_index.keys()):
+                for tc_obj in tool_calls_by_index[idx]:
+                    if tc_obj.function.name:
+                        tool_calls.append({
+                            "id": tc_obj.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc_obj.function.name,
+                                "arguments": tc_obj.function.arguments
+                            }
+                        })
+
+            if tool_calls:
+                # If sequential, only keep the first tool call
+                if self._should_handle_sequentially():
+                    tool_calls = [tool_calls[0]]
+
+                # Add the assistant's composite tool call message to history
+                assistant_msg = {"role": "assistant", "tool_calls": tool_calls, "content": full_content or None}
+                messages.append(assistant_msg)
+                
+                for tool_call in tool_calls:
+                    result = self._execute_tool(tool_call)
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "content": str(result)
+                    })
+                
+                # Loop back to continue the conversation with tool results
+                continue
+            
+            # No tool calls, store final content and finish
+            messages.append({"role": "assistant", "content": full_content})
+            self._update_history(messages)
+            return
+
+    async def astream(self, prompt: str, tools: Optional[List[Dict[str, Any]]] = None, **kwargs) -> AsyncGenerator[str, None]:
+        """
+        Execute an asynchronous streaming completion with automatic tool calling.
+        """
+        messages = self._prepare_messages(prompt)
+        tools = tools or self.tools
+        
+        while True:
+            response = await litellm.acompletion(
+                model=self.model,
+                messages=messages,
+                api_key=self.api_key,
+                base_url=self.base_url,
+                stream=True,
+                tools=tools,
+                **{**self.extra_kwargs, **kwargs}
+            )
+            
+            full_content = ""
+            tool_calls_by_index = {}
+            
+            async for chunk in response:
+                delta = chunk.choices[0].delta
+                if delta.content:
+                    full_content += delta.content
+                    yield delta.content
+                
+                if hasattr(delta, "tool_calls") and delta.tool_calls:
+                    for tc_delta in delta.tool_calls:
+                        idx = tc_delta.index
+                        if idx not in tool_calls_by_index:
+                            tool_calls_by_index[idx] = []
+                        
+                        last_tc = tool_calls_by_index[idx][-1] if tool_calls_by_index[idx] else None
+                        start_new = False
+                        if last_tc is None:
+                            start_new = True
+                        else:
+                            if tc_delta.function and tc_delta.function.name and last_tc.function.name:
+                                start_new = True
+                            elif tc_delta.id and last_tc.id and tc_delta.id != last_tc.id:
+                                start_new = True
+                        
+                        if start_new:
+                            from types import SimpleNamespace
+                            new_tc = SimpleNamespace(
+                                id=tc_delta.id,
+                                function=SimpleNamespace(
+                                    name=tc_delta.function.name if tc_delta.function else None,
+                                    arguments=tc_delta.function.arguments if tc_delta.function else ""
+                                )
+                            )
+                            tool_calls_by_index[idx].append(new_tc)
+                        else:
+                            if tc_delta.id:
+                                last_tc.id = tc_delta.id
+                            if tc_delta.function:
+                                if tc_delta.function.name:
+                                    last_tc.function.name = (last_tc.function.name or "") + tc_delta.function.name
+                                if tc_delta.function.arguments:
+                                    if last_tc.function.arguments is None:
+                                        last_tc.function.arguments = ""
+                                    last_tc.function.arguments += tc_delta.function.arguments
+
+            tool_calls = []
+            for idx in sorted(tool_calls_by_index.keys()):
+                for tc_obj in tool_calls_by_index[idx]:
+                    if tc_obj.function.name:
+                        tool_calls.append({
+                            "id": tc_obj.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc_obj.function.name,
+                                "arguments": tc_obj.function.arguments
+                            }
+                        })
+
+            if tool_calls:
+                if self._should_handle_sequentially():
+                    tool_calls = [tool_calls[0]]
+
+                assistant_msg = {"role": "assistant", "tool_calls": tool_calls, "content": full_content or None}
+                messages.append(assistant_msg)
+                
+                for tool_call in tool_calls:
+                    result = self._execute_tool(tool_call)
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "content": str(result)
+                    })
+                continue
+            
+            messages.append({"role": "assistant", "content": full_content})
+            self._update_history(messages)
+            return

litellm_adk/core/base.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional, Union, Generator, AsyncGenerator
+
+class BaseAgent(ABC):
+    """
+    Abstract Base Class for all agents.
+    """
+    @abstractmethod
+    def invoke(self, prompt: str, **kwargs) -> Any:
+        pass
+
+    @abstractmethod
+    async def ainvoke(self, prompt: str, **kwargs) -> Any:
+        pass

litellm_adk/memory/__init__.py

@@ -0,0 +1,6 @@
+from .base import BaseMemory
+from .in_memory import InMemoryMemory
+from .file import FileMemory
+from .mongodb import MongoDBMemory
+
+__all__ = ["BaseMemory", "InMemoryMemory", "FileMemory", "MongoDBMemory"]

litellm_adk/memory/base.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+
+class BaseMemory(ABC):
+    """
+    Abstract Base Class for memory persistence.
+    """
+    
+    @abstractmethod
+    def get_messages(self, session_id: str) -> List[Dict[str, Any]]:
+        """Retrieve all messages for a given session."""
+        pass
+
+    @abstractmethod
+    def add_message(self, session_id: str, message: Dict[str, Any]):
+        """Add a single message to a session."""
+        pass
+
+    @abstractmethod
+    def add_messages(self, session_id: str, messages: List[Dict[str, Any]]):
+        """Add multiple messages to a session."""
+        pass
+
+    @abstractmethod
+    def clear(self, session_id: str):
+        """Clear history for a session."""
+        pass

litellm_adk/memory/file.py

@@ -0,0 +1,47 @@
+import json
+import os
+from typing import List, Dict, Any, Optional
+from .base import BaseMemory
+
+class FileMemory(BaseMemory):
+    """
+    JSON file-based persistence for conversation history.
+    """
+    def __init__(self, file_path: str = "conversations.json"):
+        self.file_path = file_path
+        self._cache: Dict[str, List[Dict[str, Any]]] = {}
+        self._load()
+
+    def _load(self):
+        if os.path.exists(self.file_path):
+            with open(self.file_path, "r", encoding="utf-8") as f:
+                try:
+                    self._cache = json.load(f)
+                except json.JSONDecodeError:
+                    self._cache = {}
+        else:
+            self._cache = {}
+
+    def _save(self):
+        with open(self.file_path, "w", encoding="utf-8") as f:
+            json.dump(self._cache, f, indent=2, ensure_ascii=False)
+
+    def get_messages(self, session_id: str) -> List[Dict[str, Any]]:
+        return self._cache.get(session_id, []).copy()
+
+    def add_message(self, session_id: str, message: Dict[str, Any]):
+        if session_id not in self._cache:
+            self._cache[session_id] = []
+        self._cache[session_id].append(message)
+        self._save()
+
+    def add_messages(self, session_id: str, messages: List[Dict[str, Any]]):
+        if session_id not in self._cache:
+            self._cache[session_id] = []
+        self._cache[session_id].extend(messages)
+        self._save()
+
+    def clear(self, session_id: str):
+        if session_id in self._cache:
+            self._cache[session_id] = []
+            self._save()

litellm_adk/memory/in_memory.py

@@ -0,0 +1,26 @@
+from typing import List, Dict, Any
+from .base import BaseMemory
+
+class InMemoryMemory(BaseMemory):
+    """
+    Standard in-memory store for conversation history.
+    """
+    def __init__(self):
+        self._storage: Dict[str, List[Dict[str, Any]]] = {}
+
+    def get_messages(self, session_id: str) -> List[Dict[str, Any]]:
+        return self._storage.get(session_id, []).copy()
+
+    def add_message(self, session_id: str, message: Dict[str, Any]):
+        if session_id not in self._storage:
+            self._storage[session_id] = []
+        self._storage[session_id].append(message)
+
+    def add_messages(self, session_id: str, messages: List[Dict[str, Any]]):
+        if session_id not in self._storage:
+            self._storage[session_id] = []
+        self._storage[session_id].extend(messages)
+
+    def clear(self, session_id: str):
+        if session_id in self._storage:
+            self._storage[session_id] = []

litellm_adk/memory/mongodb.py

@@ -0,0 +1,47 @@
+from typing import List, Dict, Any, Optional
+from .base import BaseMemory
+import pymongo
+
+class MongoDBMemory(BaseMemory):
+    """
+    MongoDB-based persistence for conversation history.
+    """
+    def __init__(
+        self, 
+        connection_string: str = "mongodb://localhost:27017/",
+        database_name: str = "litellm_adk",
+        collection_name: str = "conversations"
+    ):
+        self.client = pymongo.MongoClient(connection_string)
+        self.db = self.client[database_name]
+        self.collection = self.db[collection_name]
+        # Create index on session_id for faster lookups
+        self.collection.create_index("session_id", unique=True)
+
+    def get_messages(self, session_id: str) -> List[Dict[str, Any]]:
+        doc = self.collection.find_one({"session_id": session_id})
+        if doc:
+            # MongoDB returns a list of dicts, but we need to ensure 
+            # we return a copy to prevent in-place modifications
+            return list(doc.get("messages", []))
+        return []
+
+    def add_message(self, session_id: str, message: Dict[str, Any]):
+        self.collection.update_one(
+            {"session_id": session_id},
+            {"$push": {"messages": message}},
+            upsert=True
+        )
+
+    def add_messages(self, session_id: str, messages: List[Dict[str, Any]]):
+        self.collection.update_one(
+            {"session_id": session_id},
+            {"$push": {"messages": {"$each": messages}}},
+            upsert=True
+        )
+
+    def clear(self, session_id: str):
+        self.collection.update_one(
+            {"session_id": session_id},
+            {"$set": {"messages": []}}
+        )

litellm_adk/observability/logger.py

@@ -0,0 +1,19 @@
+import sys
+from loguru import logger
+from ..config.settings import settings
+
+def setup_logger():
+    """
+    Configures loguru logger based on application settings.
+    """
+    logger.remove()  # Remove default handler
+    logger.add(
+        sys.stderr,
+        format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+        level=settings.log_level
+    )
+    return logger
+
+# Initialize global logger
+adk_logger = setup_logger()
+adk_logger.info("LiteLLM ADK Logger Initialized")

litellm_adk/tools/__init__.py

@@ -0,0 +1,3 @@
+from .registry import tool, tool_registry
+
+__all__ = ["tool", "tool_registry"]

litellm_adk/tools/registry.py

@@ -0,0 +1,86 @@
+import inspect
+import json
+from typing import Any, Callable, Dict, List, Optional, Type
+from pydantic import BaseModel, create_model
+from ..observability.logger import adk_logger
+
+class ToolRegistry:
+    """
+    Registry for managing tools that can be called by agents.
+    """
+    def __init__(self):
+        self._tools: Dict[str, Dict[str, Any]] = {}
+
+    def register(self, name_or_func: Any = None):
+        """
+        Decorator to register a function as a tool.
+        Supports both @tool and @tool(name="...")
+        """
+        if callable(name_or_func):
+            self._register_function(name_or_func)
+            return name_or_func
+
+        def decorator(func: Callable):
+            self._register_function(func, name_or_func)
+            return func
+        return decorator
+
+    def _register_function(self, func: Callable, name: Optional[str] = None) -> Dict[str, Any]:
+        """Internal helper to register a function and return its definition."""
+        tool_name = name or func.__name__
+        description = func.__doc__ or f"Tool: {tool_name}"
+        
+        sig = inspect.signature(func)
+        parameters = {}
+        for param_name, param in sig.parameters.items():
+            if param_name == "self": continue
+            param_type = "string"
+            if param.annotation == int: param_type = "integer"
+            elif param.annotation == float: param_type = "number"
+            elif param.annotation == bool: param_type = "boolean"
+            
+            parameters[param_name] = {
+                "type": param_type,
+                "description": f"Parameter {param_name}"
+            }
+
+        definition = {
+            "type": "function",
+            "function": {
+                "name": tool_name,
+                "description": description.strip(),
+                "parameters": {
+                    "type": "object",
+                    "properties": parameters,
+                    "required": [p.name for p in sig.parameters.values() if p.default == inspect.Parameter.empty and p.name != "self"]
+                }
+            }
+        }
+        
+        self._tools[tool_name] = {
+            "name": tool_name,
+            "func": func,
+            "definition": definition
+        }
+        adk_logger.debug(f"Registered tool: {tool_name}")
+        return definition
+
+    def get_tool_definitions(self) -> List[Dict[str, Any]]:
+        """
+        Returns list of tool definitions in OpenAI format.
+        """
+        return [t["definition"] for t in self._tools.values()]
+
+    def execute(self, name: str, **kwargs) -> Any:
+        """
+        Executes a registered tool by name with keyword arguments.
+        """
+        if name not in self._tools:
+            raise ValueError(f"Tool '{name}' not found in registry.")
+            
+        adk_logger.info(f"Executing tool: {name} with args: {kwargs}")
+        return self._tools[name]["func"](**kwargs)
+
+# Global tool registry
+tool_registry = ToolRegistry()
+tool = tool_registry.register

litellm_adk-0.1.2.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: litellm-adk
+Version: 0.1.2
+Summary: Production-grade Agent Development Kit powered by LiteLLM
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: litellm>=1.20.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pymongo>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
+
+# LiteLLM ADK (Agent Development Kit)
+
+A production-grade, highly flexible Agent Development Kit powered by [LiteLLM](https://github.com/BerriAI/litellm). 
+
+Built for developers who need to swap models, API keys, and base URLs dynamically while maintaining a robust structure for tool usage, **modular memory persistence**, and observability.
+
+## Features
+
+- **Model Agnostic**: Access 100+ LLMs (OpenAI, Anthropic, OCI Grok-3, Llama, etc.) via LiteLLM.
+- **Easy Tools**: Register Python functions with the `@tool` decorator. No manual JSON schema management.
+- **Modular Memory**: Native support for conversation persistence:
+    - `InMemoryMemory`: Fast, ephemeral storage.
+    - `FileMemory`: Simple JSON-based local persistence.
+    - `MongoDBMemory`: Scalable, remote persistence.
+- **Parallel & Sequential Execution**: Built-in support for parallel tool calls with robust stream accumulation.
+- **Dynamic Configuration**: Global defaults via `.env` or per-agent/per-request overrides.
+- **Async & Streaming**: Native support for `ainvoke`, `stream`, and `astream`.
+
+## Installation
+
+```bash
+pip install litellm-adk
+```
+
+## Quick Start
+
+### Simple Conversational Agent
+
+```python
+from litellm_adk.agents import LiteLLMAgent
+from litellm_adk.memory import FileMemory
+
+# Setup persistent memory
+memory = FileMemory("chat_history.json")
+
+agent = LiteLLMAgent(
+    model="gpt-4", 
+    memory=memory,
+    session_id="user-123"
+)
+
+response = agent.invoke("My name is Alice.")
+print(agent.invoke("What is my name?")) # Alice
+```
+
+### Registering Tools
+
+```python
+from litellm_adk.tools import tool
+
+@tool
+def get_weather(location: str):
+    """Get the current weather for a location."""
+    return f"The weather in {location} is sunny."
+
+agent = LiteLLMAgent(tools=[get_weather])
+agent.invoke("What is the weather in London?")
+```
+
+## Configuration
+
+The ADK uses `pydantic-settings`. Configure via `.env`:
+
+- `ADK_MODEL`: Default model (e.g., `gpt-4o`).
+- `ADK_API_KEY`: Default API key.
+- `ADK_BASE_URL`: Global base URL override.
+- `ADK_LOG_LEVEL`: DEBUG, INFO, etc.
+
+## Documentation
+- [Example: Basic Tools](./examples/demo.py)
+- [Example: Persistent Memory](./examples/memory_demo.py)
+
+## License
+
+MIT

litellm_adk-0.1.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+litellm_adk/__init__.py,sha256=DfQsjG9D_5OvxX-8tOtGY3kuCxYb6Hn_I-2BvnTqf0M,368
+litellm_adk/agents/__init__.py,sha256=KsiCcyYyn0iJo0sZsd7n3nJ5ezVEqJqrrTP1b9ryG0M,69
+litellm_adk/config/settings.py,sha256=sdI4PrJKzIRJPm5vEBKdiecRcjrHNASsYbmtOiBnY_c,1182
+litellm_adk/core/agent.py,sha256=_5lgc1Q6jtE4kRkM_eFijOHdaK0REzJ5jgXrMtq1bFA,22255
+litellm_adk/core/base.py,sha256=ov2bZk_a15FFGsQSdKwHrQ1cvALdZM8ByK5hGvFWyL0,386
+litellm_adk/memory/__init__.py,sha256=ICPUbV0PsTHEQSm0S35_d1ToeyrgMVFs_hRokvRRJL4,212
+litellm_adk/memory/base.py,sha256=Bm33oPaLNOJdG0RJGc38g387GSMyi_ymQjOMlDexTyk,788
+litellm_adk/memory/file.py,sha256=C0pB1pWJ4HtjCn6ICe54pL3cVmVnPI6D5jRvQaffgE4,1623
+litellm_adk/memory/in_memory.py,sha256=AVMV7iqb-UvbPE-CZmRi14LkV-7hEqrkwtkrwlxvy_w,951
+litellm_adk/memory/mongodb.py,sha256=M7IQsgahT6ALSNTQ2AKjSUWGR7uuz-KielBYIu_oLVk,1657
+litellm_adk/observability/logger.py,sha256=PXr20D7gtDIrg6eZD8Hm1-tfAuTXyUVDUMD9-8Aw32E,619
+litellm_adk/tools/__init__.py,sha256=J-Rkx-psP5sZXgcy5h4mygvQd-tZUONKLYt4LSOiEV8,82
+litellm_adk/tools/registry.py,sha256=M_48BpN0XSea_3msjGSyyDDRWu9uBNDLDtLh9Vh5yp8,3089
+litellm_adk-0.1.2.dist-info/licenses/LICENSE,sha256=BfYjX2LxngGX9t6Dk1Y5ptJNAkKcQuGG-OAR9jsKUGM,1091
+litellm_adk-0.1.2.dist-info/METADATA,sha256=AoHLb725fdU6blWIbpXX7bvQkG2ePk5kAgHXxTD_qTA,3016
+litellm_adk-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+litellm_adk-0.1.2.dist-info/top_level.txt,sha256=30MPgkTEjMUe8z-jnjMM2vbtqdghK_isd_ufRQ1w2hM,12
+litellm_adk-0.1.2.dist-info/RECORD,,

litellm_adk-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

litellm_adk-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aarumugapandi
+
+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.

litellm_adk-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+litellm_adk