llm-api-adapter 0.2.0__tar.gz

llm_api_adapter-0.2.0/MANIFEST.in

@@ -0,0 +1,9 @@
+# Exclude compiled python files and caches
+global-exclude *.py[cod]
+prune **/__pycache__
+prune **/.pytest_cache
+
+# Exclude macOS metadata and other common artifacts
+global-exclude .DS_Store
+global-exclude *.egg-info
+prune **/*.egg-info

llm_api_adapter-0.2.0/PKG-INFO

@@ -0,0 +1,254 @@
+Metadata-Version: 2.4
+Name: llm-api-adapter
+Version: 0.2.0
+Summary: Lightweight, pluggable adapter for multiple LLM APIs (OpenAI, Anthropic, Google)
+Author: Sergey Inozemtsev
+Project-URL: Repository, https://github.com/Inozem/llm_api_adapter/
+Keywords: llm,adapter,lightweight,api
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Typing :: Typed
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.32
+
+# LLM API Adapter SDK for Python
+
+## Overview
+
+This SDK for Python allows you to use LLM APIs from various companies and models through a unified interface. Currently, the project supports API integration for the following companies: OpenAI, Anthropic, and Google. At this stage, only the chat functionality is implemented.
+
+### Version
+
+Current version: 0.2.0
+
+## Features
+
+- **Unified Interface**: Work seamlessly with different LLM providers using a single, consistent API.
+- **Multiple Provider Support**: Currently supports OpenAI, Anthropic, and Google APIs, allowing easy switching between them.
+- **Chat Functionality**: Provides an easy way to interact with chat-based LLMs.
+- **Extensible Design**: Built to easily extend support for additional providers and new functionalities in the future.
+- **Error Handling**: Standardized error messages across all supported LLMs, simplifying integration and debugging.
+- **Flexible Configuration**: Manage request parameters like temperature, max tokens, and other settings for fine-tuned control.
+
+## Installation
+
+To install the SDK, you can use pip:
+
+```bash
+pip install llm_api_adapter
+```
+
+**Note:** You will need to obtain API keys from each LLM provider you wish to use (OpenAI, Anthropic, Google). Refer to their respective documentation for instructions on obtaining API keys.
+
+
+## Getting Started
+
+### Importing and Setting Up the Adapter
+
+To start using the adapter, you need to import the necessary components:
+
+```python
+from llm_api_adapter.models.messages.chat_message import (
+    AIMessage, Prompt, UserMessage
+)                                               
+from llm_api_adapter.universal_adapter import UniversalLLMAPIAdapter
+```
+
+### Sending a Simple Request
+
+The SDK supports three types of messages for interacting with the LLM:
+
+- **Prompt**: Use `Prompt` to set the context or initial prompt for the model.
+- **UserMessage**: Use `UserMessage` to send messages from the user during a conversation.
+- **AIMessage**: Use `AIMessage` to simulate responses from the assistant during a conversation.
+
+Here is an example of how to send a simple request to the adapter:
+
+```python
+messages = [
+    UserMessage("Hi! Can you explain how artificial intelligence works?")
+]
+
+adapter = UniversalLLMAPIAdapter(
+    organization="openai",
+    model="gpt-3.5-turbo",
+    api_key=openai_api_key
+)
+
+response = adapter.generate_chat_answer(
+    messages=messages,
+    max_tokens=max_tokens,
+    temperature=temperature,
+    top_p=top_p
+)
+print(response.content)
+```
+
+### Parameters
+
+- **max\_tokens**: The maximum number of tokens to generate in the response. This limits the length of the output. Default value: `256`.
+
+- **temperature**: Controls the randomness of the response. Higher values (e.g., 0.8) make the output more random, while lower values (e.g., 0.2) make it more focused and deterministic. Default value: `1.0` (range: 0 to 2).
+
+- **top\_p**: Limits the response to a certain cumulative probability. This is used to create more focused and coherent responses by considering only the highest probability options. Default value: `1.0` (range: 0 to 1).
+
+## Handling Errors
+
+### Common Errors
+
+The SDK provides a set of standardized errors for easier debugging and integration:
+
+- **LLMAPIError**: Base class for all API-related errors. This error is also used for any unexpected LLM API errors.
+
+- **LLMAPIAuthorizationError**: Raised when authentication or authorization fails.
+
+- **LLMAPIRateLimitError**: Raised when rate limits are exceeded.
+
+- **LLMAPITokenLimitError**: Raised when token limits are exceeded.
+
+- **LLMAPIClientError**: Raised when the client makes an invalid request.
+
+- **LLMAPIServerError**: Raised when the server encounters an error.
+
+- **LLMAPITimeoutError**: Raised when a request times out.
+
+- **LLMAPIUsageLimitError**: Raised when usage limits are exceeded.
+
+## Configuration and Management
+
+### Using Different Providers and Models
+
+The SDK allows you to easily switch between LLM providers and specify the model you want to use. Currently supported providers are OpenAI, Anthropic, and Google.
+
+- **OpenAI**: You can use models like `gpt-4o-mini`, `gpt-4o`, `gpt-4-turbo`, `gpt-4`, `gpt-4-turbo-preview`, `gpt-3.5-turbo`. Set the `organization` parameter to `openai` and specify the `model` name.
+
+- **Anthropic**: Available models include `claude-3-5-sonnet-20241022`, `claude-3-opus-20240229`, `claude-3-sonnet-20240229`, `claude-3-haiku-20240307`. Set the `organization` parameter to `anthropic` and specify the desired `model`.
+
+- **Google**: Models such as `gemini-1.5-flash`, `gemini-1.5-flash-8b`, `gemini-1.5-pro` can be used. Set the `organization` parameter to `google` and specify the `model`.
+
+Example:
+
+```python
+adapter = UniversalLLMAPIAdapter(
+    organization="openai",
+    model="gpt-3.5-turbo",
+    api_key=openai_api_key
+)
+```
+
+To switch to another provider, simply change the `organization` and `model` parameters.
+
+### Switching Providers
+
+Here is an example of how to switch between different LLM providers using the SDK:
+
+**Note**: Each instance of `UniversalLLMAPIAdapter` is tied to a specific provider and model. You cannot change the `organization` parameter for an existing adapter object. To use a different provider, you must create a new instance.
+
+```python
+gpt = UniversalLLMAPIAdapter(
+    organization="openai",
+    model="gpt-3.5-turbo",
+    api_key=openai_api_key
+)
+gpt_response = gpt.generate_chat_answer(messages=messages)
+print(gpt_response.content)
+
+claude = UniversalLLMAPIAdapter(
+    organization="anthropic",
+    model="claude-3-haiku-20240307",
+    api_key=anthropic_api_key
+)
+claude_response = claude.generate_chat_answer(messages=messages)
+print(claude_response.content)
+
+google = UniversalLLMAPIAdapter(
+    organization="google",
+    model="gemini-1.5-flash",
+    api_key=google_api_key
+)
+google_response = google.generate_chat_answer(messages=messages)
+print(google_response.content)
+```
+
+## Example Use Case
+
+Here is a comprehensive example that showcases all possible message types and interactions:
+
+```python
+from llm_api_adapter.models.messages.chat_message import (
+    AIMessage, Prompt, UserMessage
+)                                               
+from llm_api_adapter.universal_adapter import UniversalLLMAPIAdapter
+
+messages = [
+    Prompt(
+        "You are a friendly assistant who explains complex concepts "
+        "in simple terms."
+    ),
+    UserMessage("Hi! Can you explain how artificial intelligence works?"),
+    AIMessage(
+        "Sure! Artificial intelligence (AI) is a system that can perform "
+        "tasks requiring human-like intelligence, such as recognizing images "
+        "or understanding language. It learns by analyzing large amounts of "
+        "data, finding patterns, and making predictions."
+    ),
+    UserMessage("How does AI learn?"),
+]
+
+adapter = UniversalLLMAPIAdapter(
+    organization="openai",
+    model="gpt-3.5-turbo",
+    api_key=openai_api_key
+)
+
+response = adapter.generate_chat_answer(
+    messages=messages,
+    max_tokens=256,
+    temperature=1.0,
+    top_p=1.0
+)
+print(response.content)
+```
+
+The `ChatResponse` object returned by `generate_chat_answer` includes several attributes that provide additional details about the response. These attributes will contain data only if they are included in the response from the LLM:
+
+- **model**: The model that generated the response.
+- **response_id**: A unique identifier for the response.
+- **timestamp**: The time at which the response was generated.
+- **tokens_used**: The number of tokens used for the response.
+- **content**: The actual text content generated by the model.
+- **finish_reason**: The reason why the generation was finished (e.g., "stop" or "length").
+
+## Testing
+
+This project uses `pytest` for testing. Tests are located in the `tests/` directory.
+
+### Running Tests
+
+To run all tests, use the following command:
+
+```bash
+pytest
+```
+
+Alternatively, you can run the tests using the `tests_runner.py` script:
+
+```bash
+python tests/tests_runner.py
+```
+
+### Dependencies
+
+Ensure you have the required dependencies installed. You can install them using:
+
+```bash
+pip install -r requirements-test.txt
+```
+
+### Test Structure
+
+*   `unit/`: Contains unit tests for individual components.
+*   `integration/`: Contains integration tests to verify the interaction between different parts of the system.

llm_api_adapter-0.2.0/README.md

@@ -0,0 +1,238 @@
+# LLM API Adapter SDK for Python
+
+## Overview
+
+This SDK for Python allows you to use LLM APIs from various companies and models through a unified interface. Currently, the project supports API integration for the following companies: OpenAI, Anthropic, and Google. At this stage, only the chat functionality is implemented.
+
+### Version
+
+Current version: 0.2.0
+
+## Features
+
+- **Unified Interface**: Work seamlessly with different LLM providers using a single, consistent API.
+- **Multiple Provider Support**: Currently supports OpenAI, Anthropic, and Google APIs, allowing easy switching between them.
+- **Chat Functionality**: Provides an easy way to interact with chat-based LLMs.
+- **Extensible Design**: Built to easily extend support for additional providers and new functionalities in the future.
+- **Error Handling**: Standardized error messages across all supported LLMs, simplifying integration and debugging.
+- **Flexible Configuration**: Manage request parameters like temperature, max tokens, and other settings for fine-tuned control.
+
+## Installation
+
+To install the SDK, you can use pip:
+
+```bash
+pip install llm_api_adapter
+```
+
+**Note:** You will need to obtain API keys from each LLM provider you wish to use (OpenAI, Anthropic, Google). Refer to their respective documentation for instructions on obtaining API keys.
+
+
+## Getting Started
+
+### Importing and Setting Up the Adapter
+
+To start using the adapter, you need to import the necessary components:
+
+```python
+from llm_api_adapter.models.messages.chat_message import (
+    AIMessage, Prompt, UserMessage
+)                                               
+from llm_api_adapter.universal_adapter import UniversalLLMAPIAdapter
+```
+
+### Sending a Simple Request
+
+The SDK supports three types of messages for interacting with the LLM:
+
+- **Prompt**: Use `Prompt` to set the context or initial prompt for the model.
+- **UserMessage**: Use `UserMessage` to send messages from the user during a conversation.
+- **AIMessage**: Use `AIMessage` to simulate responses from the assistant during a conversation.
+
+Here is an example of how to send a simple request to the adapter:
+
+```python
+messages = [
+    UserMessage("Hi! Can you explain how artificial intelligence works?")
+]
+
+adapter = UniversalLLMAPIAdapter(
+    organization="openai",
+    model="gpt-3.5-turbo",
+    api_key=openai_api_key
+)
+
+response = adapter.generate_chat_answer(
+    messages=messages,
+    max_tokens=max_tokens,
+    temperature=temperature,
+    top_p=top_p
+)
+print(response.content)
+```
+
+### Parameters
+
+- **max\_tokens**: The maximum number of tokens to generate in the response. This limits the length of the output. Default value: `256`.
+
+- **temperature**: Controls the randomness of the response. Higher values (e.g., 0.8) make the output more random, while lower values (e.g., 0.2) make it more focused and deterministic. Default value: `1.0` (range: 0 to 2).
+
+- **top\_p**: Limits the response to a certain cumulative probability. This is used to create more focused and coherent responses by considering only the highest probability options. Default value: `1.0` (range: 0 to 1).
+
+## Handling Errors
+
+### Common Errors
+
+The SDK provides a set of standardized errors for easier debugging and integration:
+
+- **LLMAPIError**: Base class for all API-related errors. This error is also used for any unexpected LLM API errors.
+
+- **LLMAPIAuthorizationError**: Raised when authentication or authorization fails.
+
+- **LLMAPIRateLimitError**: Raised when rate limits are exceeded.
+
+- **LLMAPITokenLimitError**: Raised when token limits are exceeded.
+
+- **LLMAPIClientError**: Raised when the client makes an invalid request.
+
+- **LLMAPIServerError**: Raised when the server encounters an error.
+
+- **LLMAPITimeoutError**: Raised when a request times out.
+
+- **LLMAPIUsageLimitError**: Raised when usage limits are exceeded.
+
+## Configuration and Management
+
+### Using Different Providers and Models
+
+The SDK allows you to easily switch between LLM providers and specify the model you want to use. Currently supported providers are OpenAI, Anthropic, and Google.
+
+- **OpenAI**: You can use models like `gpt-4o-mini`, `gpt-4o`, `gpt-4-turbo`, `gpt-4`, `gpt-4-turbo-preview`, `gpt-3.5-turbo`. Set the `organization` parameter to `openai` and specify the `model` name.
+
+- **Anthropic**: Available models include `claude-3-5-sonnet-20241022`, `claude-3-opus-20240229`, `claude-3-sonnet-20240229`, `claude-3-haiku-20240307`. Set the `organization` parameter to `anthropic` and specify the desired `model`.
+
+- **Google**: Models such as `gemini-1.5-flash`, `gemini-1.5-flash-8b`, `gemini-1.5-pro` can be used. Set the `organization` parameter to `google` and specify the `model`.
+
+Example:
+
+```python
+adapter = UniversalLLMAPIAdapter(
+    organization="openai",
+    model="gpt-3.5-turbo",
+    api_key=openai_api_key
+)
+```
+
+To switch to another provider, simply change the `organization` and `model` parameters.
+
+### Switching Providers
+
+Here is an example of how to switch between different LLM providers using the SDK:
+
+**Note**: Each instance of `UniversalLLMAPIAdapter` is tied to a specific provider and model. You cannot change the `organization` parameter for an existing adapter object. To use a different provider, you must create a new instance.
+
+```python
+gpt = UniversalLLMAPIAdapter(
+    organization="openai",
+    model="gpt-3.5-turbo",
+    api_key=openai_api_key
+)
+gpt_response = gpt.generate_chat_answer(messages=messages)
+print(gpt_response.content)
+
+claude = UniversalLLMAPIAdapter(
+    organization="anthropic",
+    model="claude-3-haiku-20240307",
+    api_key=anthropic_api_key
+)
+claude_response = claude.generate_chat_answer(messages=messages)
+print(claude_response.content)
+
+google = UniversalLLMAPIAdapter(
+    organization="google",
+    model="gemini-1.5-flash",
+    api_key=google_api_key
+)
+google_response = google.generate_chat_answer(messages=messages)
+print(google_response.content)
+```
+
+## Example Use Case
+
+Here is a comprehensive example that showcases all possible message types and interactions:
+
+```python
+from llm_api_adapter.models.messages.chat_message import (
+    AIMessage, Prompt, UserMessage
+)                                               
+from llm_api_adapter.universal_adapter import UniversalLLMAPIAdapter
+
+messages = [
+    Prompt(
+        "You are a friendly assistant who explains complex concepts "
+        "in simple terms."
+    ),
+    UserMessage("Hi! Can you explain how artificial intelligence works?"),
+    AIMessage(
+        "Sure! Artificial intelligence (AI) is a system that can perform "
+        "tasks requiring human-like intelligence, such as recognizing images "
+        "or understanding language. It learns by analyzing large amounts of "
+        "data, finding patterns, and making predictions."
+    ),
+    UserMessage("How does AI learn?"),
+]
+
+adapter = UniversalLLMAPIAdapter(
+    organization="openai",
+    model="gpt-3.5-turbo",
+    api_key=openai_api_key
+)
+
+response = adapter.generate_chat_answer(
+    messages=messages,
+    max_tokens=256,
+    temperature=1.0,
+    top_p=1.0
+)
+print(response.content)
+```
+
+The `ChatResponse` object returned by `generate_chat_answer` includes several attributes that provide additional details about the response. These attributes will contain data only if they are included in the response from the LLM:
+
+- **model**: The model that generated the response.
+- **response_id**: A unique identifier for the response.
+- **timestamp**: The time at which the response was generated.
+- **tokens_used**: The number of tokens used for the response.
+- **content**: The actual text content generated by the model.
+- **finish_reason**: The reason why the generation was finished (e.g., "stop" or "length").
+
+## Testing
+
+This project uses `pytest` for testing. Tests are located in the `tests/` directory.
+
+### Running Tests
+
+To run all tests, use the following command:
+
+```bash
+pytest
+```
+
+Alternatively, you can run the tests using the `tests_runner.py` script:
+
+```bash
+python tests/tests_runner.py
+```
+
+### Dependencies
+
+Ensure you have the required dependencies installed. You can install them using:
+
+```bash
+pip install -r requirements-test.txt
+```
+
+### Test Structure
+
+*   `unit/`: Contains unit tests for individual components.
+*   `integration/`: Contains integration tests to verify the interaction between different parts of the system.

llm_api_adapter-0.2.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "llm-api-adapter"
+version = "0.2.0"
+keywords = ["llm", "adapter", "lightweight", "api"]
+description = "Lightweight, pluggable adapter for multiple LLM APIs (OpenAI, Anthropic, Google)"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {file = "LICENSE"}
+authors = [{name = "Sergey Inozemtsev"}]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Typing :: Typed",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+dependencies = ["requests>=2.32"]
+
+[project.urls]
+Repository = "https://github.com/Inozem/llm_api_adapter/"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["llm_api_adapter*"]
+exclude = ["tests*", "*/tests*"]

llm_api_adapter-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

llm_api_adapter-0.2.0/src/llm_api_adapter/adapters/anthropic_adapter.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+import logging
+from typing import FrozenSet, List, Optional
+
+from ..adapters.base_adapter import LLMAdapterBase
+from ..errors.llm_api_error import LLMAPIError
+from ..llms.anthropic.sync_client import ClaudeSyncClient
+from ..models.messages.chat_message import Message, Prompt
+from ..models.responses.chat_response import ChatResponse
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AnthropicAdapter(LLMAdapterBase):
+    company: str = "anthropic"
+    verified_models: FrozenSet[str] = frozenset([
+        "claude-opus-4-20250514",
+        "claude-sonnet-4-20250514",
+        "claude-3-7-sonnet-latest",
+        "claude-3-5-haiku-latest",
+        "claude-3-5-sonnet-latest",
+        "claude-3-haiku-20240307"
+    ])
+
+    def generate_chat_answer(
+        self,
+        messages: List[Message],
+        max_tokens: Optional[int] = 256,
+        temperature: float = 1.0,
+        top_p: float = 1.0
+    ) -> ChatResponse:
+        temperature = self._validate_parameter(
+            name="temperature", value=temperature, min_value=0, max_value=2
+        )
+        top_p = self._validate_parameter(
+            name="top_p", value=top_p, min_value=0, max_value=1
+        )
+        try:
+            system_prompt = ""
+            transformed_messages = []
+            for msg in messages:
+                if isinstance(msg, Prompt):
+                    system_prompt = msg.content
+                else:
+                    transformed_messages.append({
+                        "role": msg.role,
+                        "content": msg.content
+                    })
+            client = ClaudeSyncClient(api_key=self.api_key)
+            response = client.chat_completion(
+                model=self.model,
+                messages=transformed_messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                system=system_prompt,
+            )
+            return ChatResponse.from_anthropic_response(response)
+        except LLMAPIError as e:
+            self.handle_error(e, self.company)
+        except Exception as e:
+            self.handle_error(e, self.company)

llm_api_adapter-0.2.0/src/llm_api_adapter/adapters/base_adapter.py

@@ -0,0 +1,50 @@
+import logging
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import FrozenSet
+import warnings
+
+from ..models.responses.chat_response import ChatResponse
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class LLMAdapterBase(ABC):
+    model: str
+    api_key: str
+    verified_models: FrozenSet[str] = field(default_factory=frozenset)
+
+    def __post_init__(self):
+        if len(self.api_key) < 1:
+            erroe_message = "api_key must be a non-empty string"
+            logger.error(erroe_message)
+            raise ValueError(erroe_message)
+        if self.model not in self.verified_models:
+            warnings.warn(
+                (f"Model '{self.model}' is not verified for this adapter. "
+                 "Continuing with the selected adapter."),
+                UserWarning
+            )
+            logger.warning(f"Unverified model used: {self.model}")
+
+    @abstractmethod
+    def generate_chat_answer(self, **kwargs) -> ChatResponse:
+        """
+        Generates a response based on the provided conversation.
+        """
+        pass
+
+    def _validate_parameter(
+        self, name: str, value: float, min_value: float, max_value: float
+    ) -> float:
+        if not (min_value <= value <= max_value):
+            error_message = (f"{name} must be between {min_value} and "
+                             f"{max_value}, got {value}")
+            logger.error(error_message)
+            raise ValueError(error_message)
+        return value
+
+    @classmethod
+    def handle_error(cls, error: Exception, company: str):
+        logger.error(f"Error in company {company}: {error}")
+        raise error

llm_api_adapter-0.2.0/src/llm_api_adapter/adapters/google_adapter.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+import logging
+from typing import FrozenSet, List, Optional
+
+from ..adapters.base_adapter import LLMAdapterBase
+from ..errors.llm_api_error import LLMAPIError
+from ..llms.google.sync_client import GeminiSyncClient
+from ..models.messages.chat_message import Message
+from ..models.responses.chat_response import ChatResponse
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class GoogleAdapter(LLMAdapterBase):
+    company: str = "google"
+    verified_models: FrozenSet[str] = frozenset([
+        "gemini-2.5-pro",
+        "gemini-2.5-flash",
+        "gemini-2.5-flash-lite",
+        "gemini-2.0-flash",
+        "gemini-2.0-flash-lite"
+    ])
+
+    def generate_chat_answer(
+        self,
+        messages: List[Message],
+        max_tokens: Optional[int] = 256,
+        temperature: float = 1.0,
+        top_p: float = 1.0
+    ) -> ChatResponse:
+        temperature = self._validate_parameter(
+            name="temperature", value=temperature, min_value=0, max_value=2
+        )
+        top_p = self._validate_parameter(
+            name="top_p", value=top_p, min_value=0, max_value=1
+        )
+        try:
+            transformed_messages = []
+            prompt = None
+            for msg in messages:
+                if hasattr(msg, "role") and hasattr(msg, "content"):
+                    if msg.role == "system" or isinstance(msg, ()):
+                        pass
+                    if isinstance(msg, type) and msg == "Prompt":
+                        prompt = {
+                            "parts": [{"text": msg.content}]
+                        }
+                    else:
+                        transformed_messages.append({
+                            "role": "user" if msg.role == "user" else "model",
+                            "parts": [{"text": msg.content}]
+                        })
+            payload = {
+                "contents": transformed_messages,
+                **({"system_instruction": prompt} if prompt else {}),
+                "generationConfig": {
+                    "maxOutputTokens": max_tokens,
+                    "temperature": temperature,
+                    "topP": top_p,
+                },
+            }
+            client = GeminiSyncClient(self.api_key)
+            response_json = client.chat_completion(
+                model=self.model,
+                **payload
+            )
+            return ChatResponse.from_google_response(response_json)
+        except LLMAPIError as e:
+            self.handle_error(e, self.company)
+        except Exception as e:
+            self.handle_error(e, self.company)

llm_api_adapter-0.2.0/src/llm_api_adapter/adapters/openai_adapter.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+import logging
+from typing import FrozenSet, List, Optional
+
+from ..adapters.base_adapter import LLMAdapterBase
+from ..errors.llm_api_error import LLMAPIError
+from ..llms.openai.sync_client import OpenAISyncClient
+from ..models.messages.chat_message import Message
+from ..models.responses.chat_response import ChatResponse
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OpenAIAdapter(LLMAdapterBase):
+    company: str = "openai"
+    verified_models: FrozenSet[str] = frozenset([
+        "gpt-4.1",
+        "gpt-4.1-mini",
+        "gpt-4.1-nano",
+        "gpt-4.5-preview",
+        "gpt-4o",
+        "gpt-4o-mini",
+        "gpt-4-turbo",
+        "gpt-4",
+        "gpt-4-turbo-preview",
+        "gpt-3.5-turbo",
+    ])
+
+    def generate_chat_answer(
+        self,
+        messages: List[Message],
+        max_tokens: Optional[int] = 256,
+        temperature: float = 1.0,
+        top_p: float = 1.0
+    ) -> ChatResponse:
+        temperature = self._validate_parameter(
+            name="temperature", value=temperature, min_value=0, max_value=2
+        )
+        top_p = self._validate_parameter(
+            name="top_p", value=top_p, min_value=0, max_value=1
+        )
+        try:
+            transformed_messages = []
+            for msg in messages:
+                transformed_messages.append(
+                    {"role": msg.role, "content": msg.content}
+                )
+            client = OpenAISyncClient(api_key=self.api_key)
+            response = client.chat_completion(
+                model=self.model,
+                messages=transformed_messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+            )
+            return ChatResponse.from_openai_response(response)
+        except LLMAPIError as e:
+            self.handle_error(e, self.company)
+        except Exception as e:
+            self.handle_error(e, self.company)

llm_api_adapter-0.2.0/src/llm_api_adapter/errors/llm_api_error.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class LLMAPIError(Exception):
+    """Base class for API-related errors."""
+    message: str = "An API error occurred."
+    detail: Optional[str] = None
+
+    def __post_init__(self):
+        full_message = self.message
+        if self.detail:
+            full_message = f"{self.message} Detail: {self.detail}"
+        super().__init__(full_message)
+
+
+@dataclass
+class LLMAPIAuthorizationError(LLMAPIError):
+    """Raised when authentication or authorization fails."""
+    message: str = "Authentication or authorization failed."
+    openai_api_errors = ["InvalidAuthenticationError", "AuthenticationError"]
+    google_api_errors = ["INVALID_ARGUMENT", "PERMISSION_DENIED"]
+    anthropic_api_errors = ["AuthenticationError", "PermissionError"]
+
+
+@dataclass
+class LLMAPIRateLimitError(LLMAPIError):
+    """Raised when rate limits are exceeded."""
+    message: str = "Rate limit exceeded."
+    openai_api_errors = ["RateLimitError"]
+    google_api_errors = ["RESOURCE_EXHAUSTED"]
+    anthropic_api_errors = ["RateLimitError"]
+
+
+@dataclass
+class LLMAPITokenLimitError(LLMAPIError):
+    """Raised when token limits are exceeded."""
+    message: str = "Token limit exceeded."
+    openai_api_errors = ["MaxTokensExceededError", "TokenLimitError"]
+    google_api_errors = []
+    anthropic_api_errors = []
+
+
+@dataclass
+class LLMAPIClientError(LLMAPIError):
+    """Raised when the client makes an invalid request."""
+    message: str = "Client error occurred."
+    openai_api_errors = ["InvalidRequestError", "BadRequestError"]
+    google_api_errors = [
+        "INVALID_ARGUMENT", "FAILED_PRECONDITION", "NOT_FOUND"
+    ]
+    anthropic_api_errors = [
+        "InvalidRequestError", "RequestTooLargeError", "NotFoundError"
+    ]
+
+
+@dataclass
+class LLMAPIServerError(LLMAPIError):
+    """Raised when the server encounters an error."""
+    message: str = "Server error occurred."
+    openai_api_errors = ["InternalServerError", "ServiceUnavailableError"]
+    google_api_errors = ["INTERNAL", "UNAVAILABLE"]
+    anthropic_api_errors = ["APIError", "OverloadedError"]
+
+
+@dataclass
+class LLMAPITimeoutError(LLMAPIError):
+    """Raised when a request times out."""
+    message: str = "Request timed out."
+    openai_api_errors = ["TimeoutError"]
+    google_api_errors = ["DEADLINE_EXCEEDED"]
+    anthropic_api_errors = []
+
+
+@dataclass
+class LLMAPIUsageLimitError(LLMAPIError):
+    """Raised when usage limits are exceeded."""
+    message: str = "Usage limit exceeded."
+    openai_api_errors = ["UsageLimitError", "QuotaExceededError"]
+    google_api_errors = []
+    anthropic_api_errors = []

llm_api_adapter-0.2.0/src/llm_api_adapter/llms/anthropic/sync_client.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+import logging
+
+import requests
+
+from ...errors.llm_api_error import (
+    LLMAPIAuthorizationError,
+    LLMAPIRateLimitError,
+    LLMAPITokenLimitError,
+    LLMAPIClientError,
+    LLMAPIServerError,
+    LLMAPITimeoutError,
+)
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class ClaudeSyncClient:
+    api_key: str
+    endpoint: str = "https://api.anthropic.com/v1"
+    api_version: str = "2023-06-01"
+
+    def _headers(self):
+        return {
+            "x-api-key": self.api_key,
+            "anthropic-version": self.api_version,
+            "Content-Type": "application/json"
+        }
+
+    def chat_completion(self, model: str, **kwargs):
+        url = f"{self.endpoint}/messages"
+        payload = {"model": model, **kwargs}
+        response = self._send_request(url, payload)
+        return response.json()
+
+    def _send_request(self, url, payload):
+        try:
+            response = requests.post(
+                url, headers=self._headers(), json=payload
+            )
+            response.raise_for_status()
+        except requests.exceptions.Timeout as e:
+            logger.error(f"Request timed out: {e}")
+            raise LLMAPITimeoutError(detail=str(e))
+        except requests.exceptions.HTTPError as http_err:
+            logger.error(f"HTTP error occurred: {http_err}")
+            self._handle_http_error(http_err)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request exception: {e}")
+            raise LLMAPIClientError(detail=str(e))
+        return response
+
+    def _handle_http_error(self, http_err):
+        status_code = http_err.response.status_code
+        try:
+            error_json = http_err.response.json()
+            error_type = error_json.get("type")
+            error_message = error_json.get("message")
+        except Exception:
+            error_type = None
+            error_message = None
+        detail = error_message or str(http_err)
+        error_map = {
+            401: LLMAPIAuthorizationError,
+            429: LLMAPIRateLimitError,
+        }
+        if status_code in error_map:
+            raise error_map[status_code](detail=detail)
+        elif error_type in LLMAPIAuthorizationError.anthropic_api_errors:
+            raise LLMAPIAuthorizationError(detail=detail)
+        elif error_type in LLMAPIRateLimitError.anthropic_api_errors:
+            raise LLMAPIRateLimitError(detail=detail)
+        elif error_type in LLMAPITokenLimitError.anthropic_api_errors:
+            raise LLMAPITokenLimitError(detail=detail)
+        elif 400 <= status_code < 500:
+            raise LLMAPIClientError(detail=detail)
+        elif 500 <= status_code < 600:
+            raise LLMAPIServerError(detail=detail)
+        else:
+            raise LLMAPIClientError(detail=detail)

llm_api_adapter-0.2.0/src/llm_api_adapter/llms/google/sync_client.py

@@ -0,0 +1,79 @@
+from dataclasses import dataclass
+import logging
+
+import requests
+
+from ...errors.llm_api_error import (
+    LLMAPIAuthorizationError,
+    LLMAPIRateLimitError,
+    LLMAPIClientError,
+    LLMAPIServerError,
+    LLMAPITimeoutError,
+)
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class GeminiSyncClient:
+    api_key: str
+    endpoint: str = "https://generativelanguage.googleapis.com/v1beta"
+
+    def _headers(self):
+        return {
+            "x-goog-api-key": self.api_key,
+            "Content-Type": "application/json"
+        }
+
+    def chat_completion(self, model: str, **kwargs):
+        url = f"{self.endpoint}/models/{model}:generateContent"
+        payload = {"model": model, **kwargs}
+        response = self._send_request(url, payload)
+        return response.json()
+
+    def _send_request(self, url, payload):
+        try:
+            response = requests.post(
+                url, headers=self._headers(), json=payload, timeout=30
+            )
+            response.raise_for_status()
+        except requests.exceptions.Timeout as e:
+            logger.error(f"Request timeout: {e}")
+            raise LLMAPITimeoutError(detail=str(e))
+        except requests.exceptions.HTTPError as http_err:
+            logger.error(f"HTTP error occurred: {http_err}")
+            self._handle_http_error(http_err)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Request exception: {e}")
+            raise LLMAPIClientError(detail=str(e))
+        return response
+
+    def _handle_http_error(self, http_err):
+        status_code = http_err.response.status_code
+        try:
+            error_json = http_err.response.json()
+            error_status = error_json.get("error", {}).get("status", "")
+            error_message = error_json.get("error", {}).get("message")
+        except Exception:
+            logger.warning("Failed to parse error response JSON", exc_info=True)
+            error_status = ""
+            error_message = None
+        detail = error_message or str(http_err)
+        error_map = {
+            401: LLMAPIAuthorizationError,
+            429: LLMAPIRateLimitError,
+        }
+        if status_code in error_map:
+            raise error_map[status_code](detail=detail)
+        elif error_status in LLMAPIAuthorizationError.google_api_errors:
+            raise LLMAPIAuthorizationError(detail=detail)
+        elif error_status in LLMAPIRateLimitError.google_api_errors:
+            raise LLMAPIRateLimitError(detail=detail)
+        elif 400 <= status_code < 500:
+            raise LLMAPIClientError(detail=detail)
+        elif (
+            500 <= status_code < 600
+            or error_status in LLMAPIServerError.google_api_errors
+        ):
+            raise LLMAPIServerError(detail=detail)
+        else:
+            raise LLMAPIClientError(detail=detail)

llm_api_adapter-0.2.0/src/llm_api_adapter/llms/openai/sync_client.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+import logging
+
+import requests
+
+from ...errors.llm_api_error import (
+    LLMAPIAuthorizationError,
+    LLMAPIRateLimitError,
+    LLMAPITokenLimitError,
+    LLMAPIClientError,
+    LLMAPIServerError,
+    LLMAPITimeoutError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OpenAISyncClient:
+    api_key: str
+    endpoint: str = "https://api.openai.com/v1"
+
+    def _headers(self):
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+    def chat_completion(self, model: str, **kwargs):
+        url = f"{self.endpoint}/chat/completions"
+        payload = {"model": model, **kwargs}
+        response = self._send_request(url, payload)
+        return response.json()
+
+    def _send_request(self, url, payload):
+        try:
+            response = requests.post(
+                url, headers=self._headers(), json=payload
+            )
+            response.raise_for_status()
+        except requests.exceptions.Timeout as e:
+            logger.error("Timeout error: %s", e)
+            raise LLMAPITimeoutError(detail=str(e))
+        except requests.exceptions.HTTPError as http_err:
+            logger.error("HTTP error: %s", http_err)
+            self._handle_http_error(http_err)
+        except requests.exceptions.RequestException as e:
+            logger.error("Request exception: %s", e)
+            raise LLMAPIClientError(detail=str(e))
+        return response
+
+    def _handle_http_error(self, http_err):
+        status_code = http_err.response.status_code
+        try:
+            error_json = http_err.response.json()
+            error = error_json.get("error", {})
+            error_type = error.get("type") or error.get("code")
+            error_message = error.get("message")
+        except Exception as e:
+            logger.warning("Failed to parse error response: %s", e)
+            error_type = None
+            error_message = None
+        detail = error_message or str(http_err)
+        error_map = {
+            401: LLMAPIAuthorizationError,
+            429: LLMAPIRateLimitError,
+        }
+        if status_code in error_map:
+            raise error_map[status_code](detail=detail)
+        elif error_type in LLMAPIAuthorizationError.openai_api_errors:
+            raise LLMAPIAuthorizationError(detail=detail)
+        elif error_type in LLMAPIRateLimitError.openai_api_errors:
+            raise LLMAPIRateLimitError(detail=detail)
+        elif error_type in LLMAPITokenLimitError.openai_api_errors:
+            raise LLMAPITokenLimitError(detail=detail)
+        elif 400 <= status_code < 500:
+            raise LLMAPIClientError(detail=detail)
+        elif 500 <= status_code < 600:
+            raise LLMAPIServerError(detail=detail)
+        else:
+            raise LLMAPIClientError(detail=detail)

llm_api_adapter-0.2.0/src/llm_api_adapter/models/messages/chat_message.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Message:
+    content: str
+
+
+@dataclass
+class Prompt(Message):
+    role: str = field(default="system", init=False)
+
+
+@dataclass
+class UserMessage(Message):
+    role: str = field(default="user", init=False)
+
+
+@dataclass
+class AIMessage(Message):
+    role: str = field(default="assistant", init=False)

llm_api_adapter-0.2.0/src/llm_api_adapter/models/responses/chat_response.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ChatResponse:
+    model: Optional[str] = None
+    response_id: Optional[str] = None
+    timestamp: Optional[int] = None
+    tokens_used: Optional[int] = None
+    content: str = field(default_factory=str)
+    finish_reason: Optional[str] = None
+
+    @classmethod
+    def from_openai_response(cls, api_response: dict) -> "ChatResponse":
+        return cls(
+            model=api_response.get("model"),
+            response_id=api_response.get("id"),
+            timestamp=api_response.get("created"),
+            tokens_used=api_response.get("usage", {}).get("total_tokens"),
+            content=api_response["choices"][0]["message"]["content"],
+            finish_reason=api_response["choices"][0].get("finish_reason")
+        )
+
+    @classmethod
+    def from_anthropic_response(cls, api_response: dict) -> "ChatResponse":
+        print(f"API response {api_response}")
+        usage = api_response.get("usage")
+        tokens_used = usage.get("input_tokens") + usage.get("output_tokens")
+        return cls(
+            model=api_response.get("model"),
+            response_id=api_response.get("id"),
+            tokens_used=tokens_used,
+            content=api_response.get("content")[0].get("text"),
+            finish_reason=api_response.get("stop_reason")
+        )
+
+    @classmethod
+    def from_google_response(cls, api_response: dict) -> "ChatResponse":
+        first_candidate = api_response["candidates"][0]
+        return cls(
+            tokens_used=api_response["usageMetadata"]["totalTokenCount"],
+            content=first_candidate["content"]["parts"][0]["text"],
+            finish_reason=str(first_candidate["finishReason"])
+        )

llm_api_adapter-0.2.0/src/llm_api_adapter/universal_adapter.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass, fields
+import logging
+from typing import Any
+
+from .adapters.base_adapter import LLMAdapterBase
+from .adapters.anthropic_adapter import AnthropicAdapter
+from .adapters.openai_adapter import OpenAIAdapter
+from .adapters.google_adapter import GoogleAdapter
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class UniversalLLMAPIAdapter:
+    organization: str
+    model: str
+    api_key: str
+
+    def __post_init__(self) -> None:
+        if not self.organization or not isinstance(self.organization, str):
+            raise ValueError("Invalid organization")
+        if not self.model or not isinstance(self.model, str):
+            raise ValueError("Invalid model")
+        if not self.api_key or not isinstance(self.api_key, str):
+            raise ValueError("Invalid API key")
+        self.adapter = self._select_adapter(self.organization, self.model,
+                                            self.api_key)
+
+    def _select_adapter(
+        self, organization: str, model: str, api_key: str
+    ) -> LLMAdapterBase:
+        """
+        Selects the adapter based on the company.
+        """
+        for adapter_class in LLMAdapterBase.__subclasses__():
+            company_field = None
+            for field in fields(adapter_class):
+                if field.name == 'company':
+                    company_field = field
+                    break
+            if company_field and company_field.default == organization:
+                return adapter_class(model=model, api_key=api_key)
+        error_message = f"Unsupported organization: {organization}"
+        logger.error(error_message)
+        raise ValueError(error_message)
+
+    def __getattr__(self, name: str) -> Any:
+        """
+        Redirects method calls to the selected adapter.
+        """
+        if hasattr(self.adapter, name):
+            return getattr(self.adapter, name)
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        )

llm_api_adapter-0.2.0/src/llm_api_adapter.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+MANIFEST.in
+README.md
+pyproject.toml
+src/llm_api_adapter/__init__.py
+src/llm_api_adapter/universal_adapter.py
+src/llm_api_adapter/adapters/__init__.py
+src/llm_api_adapter/adapters/anthropic_adapter.py
+src/llm_api_adapter/adapters/base_adapter.py
+src/llm_api_adapter/adapters/google_adapter.py
+src/llm_api_adapter/adapters/openai_adapter.py
+src/llm_api_adapter/errors/__init__.py
+src/llm_api_adapter/errors/llm_api_error.py
+src/llm_api_adapter/llms/__init__.py
+src/llm_api_adapter/llms/anthropic/__init__.py
+src/llm_api_adapter/llms/anthropic/sync_client.py
+src/llm_api_adapter/llms/google/__init__.py
+src/llm_api_adapter/llms/google/sync_client.py
+src/llm_api_adapter/llms/openai/__init__.py
+src/llm_api_adapter/llms/openai/sync_client.py
+src/llm_api_adapter/models/__init__.py
+src/llm_api_adapter/models/messages/__init__.py
+src/llm_api_adapter/models/messages/chat_message.py
+src/llm_api_adapter/models/responses/__init__.py
+src/llm_api_adapter/models/responses/chat_response.py
+tests/tests_runner.py

llm_api_adapter-0.2.0/tests/tests_runner.py

@@ -0,0 +1,19 @@
+import pytest
+
+if __name__ == "__main__":
+    unit_result = pytest.main([
+        "-v",
+        "--rootdir=.",
+        "--pyargs",
+        "unit"
+    ])
+    if unit_result == 0:
+        integ_result = pytest.main([
+            "-v",
+            "--rootdir=.",
+            "--pyargs",
+            "integration"
+        ])
+        exit(integ_result)
+    else:
+        exit(unit_result)