promptbuilder 0.4.19__py3-none-any.whl → 0.4.21__py3-none-any.whl

promptbuilder/llm_client/__init__.py

@@ -2,3 +2,4 @@ from .base_client import BaseLLMClient, BaseLLMClientAsync, CachedLLMClient, Cac
 from .types import Completion, Message, Choice, Usage, Response, Candidate, Content, Part, UsageMetadata, Tool, ToolConfig, ThinkingConfig, FunctionCall, FunctionDeclaration
 from .main import get_client, get_async_client, configure, sync_existing_clients_with_global_config, get_models_list
 from .utils import DecoratorConfigs, RpmLimitConfig, RetryConfig
+from.exceptions import APIError, ClientError, ServerError

promptbuilder/llm_client/anthropic_client.py

@@ -1,14 +1,21 @@
 import os
-from typing import AsyncIterator, Iterator
 import base64
+from functools import wraps
+from typing import AsyncIterator, Iterator, Callable, ParamSpec, Awaitable
+
 from pydantic import BaseModel
-from anthropic import Anthropic, AsyncAnthropic, Stream, AsyncStream
+from anthropic import Anthropic, AsyncAnthropic, Stream, AsyncStream, APIError as AnthropicAPIError
 from anthropic.types import RawMessageStreamEvent
 
 from promptbuilder.llm_client.base_client import BaseLLMClient, BaseLLMClientAsync, ResultType
 from promptbuilder.llm_client.types import Response, Content, Candidate, UsageMetadata, Part, ThinkingConfig, Tool, ToolConfig, FunctionCall, MessageDict, Model
 from promptbuilder.llm_client.config import DecoratorConfigs
 from promptbuilder.prompt_builder import PromptBuilder
+from promptbuilder.llm_client.utils import inherited_decorator
+from promptbuilder.llm_client.exceptions import APIError
+
+
+P = ParamSpec("P")
 
 
 def sum_optional_ints(a: int | None, b: int | None) -> int | None:
@@ -70,6 +77,26 @@ class AnthropicDefaultMaxTokensStrategy(DefaultMaxTokensStrategy):
             return 32000
 
 
+@inherited_decorator
+def _error_handler(func: Callable[P, Response]) -> Callable[P, Response]:
+    """
+    Decorator to catch error from anthropic and transform it into unified one
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except AnthropicAPIError as e:
+            code = getattr(e, "status_code", None)
+            response = getattr(e, "response", None)
+            status = getattr(response, "reason_phrase", None)
+            response_json = {
+                "status": status,
+                "message": e.message,
+            }
+            raise APIError(code, response_json, response)
+    return wrapper
+
 class AnthropicStreamIterator:
     def __init__(self, anthropic_iterator: Stream[RawMessageStreamEvent]):
         self._anthropic_iterator = anthropic_iterator
@@ -109,13 +136,15 @@ class AnthropicLLMClient(BaseLLMClient):
     def __init__(
         self,
         model: str,
-        api_key: str = os.getenv("ANTHROPIC_API_KEY"),
+        api_key: str | None = None,
         decorator_configs: DecoratorConfigs | None = None,
         default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         default_max_tokens_strategy: DefaultMaxTokensStrategy = AnthropicDefaultMaxTokensStrategy(),
         **kwargs,
     ):
+        if api_key is None:
+            api_key = os.getenv("ANTHROPIC_API_KEY")
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create an anthropic llm client you need to either set the environment variable ANTHROPIC_API_KEY or pass the api_key in string format")
         super().__init__(AnthropicLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
@@ -162,6 +191,7 @@ class AnthropicLLMClient(BaseLLMClient):
                 anthropic_messages.append({"role": role, "content": content})
         return anthropic_messages
 
+    @_error_handler
     def create(
         self,
         messages: list[Content],
@@ -278,6 +308,7 @@ class AnthropicLLMClient(BaseLLMClient):
         else:
             raise ValueError(f"Unsupported result type: {result_type}")
     
+    @_error_handler
     def create_stream(
         self,
         messages: list[Content],
@@ -334,6 +365,26 @@ class AnthropicLLMClient(BaseLLMClient):
         return models
 
 
+@inherited_decorator
+def _error_handler_async(func: Callable[P, Awaitable[Response]]) -> Callable[P, Awaitable[Response]]:
+    """
+    Decorator to catch error from anthropic and transform it into unified one
+    """
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except AnthropicAPIError as e:
+            code = getattr(e, "status_code", None)
+            response = getattr(e, "response", None)
+            status = getattr(response, "reason_phrase", None)
+            response_json = {
+                "status": status,
+                "message": e.message,
+            }
+            raise APIError(code, response_json, response)
+    return wrapper
+
 class AnthropicStreamIteratorAsync:
     def __init__(self, anthropic_iterator: AsyncStream[RawMessageStreamEvent]):
         self._anthropic_iterator = anthropic_iterator
@@ -373,13 +424,15 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
     def __init__(
         self,
         model: str,
-        api_key: str = os.getenv("ANTHROPIC_API_KEY"),
+        api_key: str | None = None,
         decorator_configs: DecoratorConfigs | None = None,
         default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         default_max_tokens_strategy: DefaultMaxTokensStrategy = AnthropicDefaultMaxTokensStrategy(),
         **kwargs,
     ):
+        if api_key is None:
+            api_key = os.getenv("ANTHROPIC_API_KEY")
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create an anthropic llm client you need to either set the environment variable ANTHROPIC_API_KEY or pass the api_key in string format")
         super().__init__(AnthropicLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
@@ -391,6 +444,7 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
     def api_key(self) -> str:
         return self._api_key
     
+    @_error_handler_async
     async def create(
         self,
         messages: list[Content],
@@ -513,6 +567,7 @@ class AnthropicLLMClientAsync(BaseLLMClientAsync):
         else:
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
     
+    @_error_handler_async
     async def create_stream(
         self,
         messages: list[Content],

promptbuilder/llm_client/bedrock_client.py

@@ -1,24 +1,51 @@
 import os
-from typing import AsyncIterator, Iterator, Any
+from functools import wraps
+from typing import AsyncIterator, Iterator, Any, Callable, ParamSpec, Awaitable
 
 import boto3
+from boto3.exceptions import Boto3Error
 import aioboto3
 from pydantic import BaseModel, ConfigDict
 from botocore.eventstream import EventStream
+from botocore.exceptions import ClientError, BotoCoreError
 
 from promptbuilder.llm_client.base_client import BaseLLMClient, BaseLLMClientAsync, ResultType
 from promptbuilder.llm_client.types import Response, Content, Candidate, UsageMetadata, Part, ThinkingConfig, Tool, ToolConfig, FunctionCall, CustomApiKey, Model
 from promptbuilder.llm_client.config import DecoratorConfigs
 from promptbuilder.prompt_builder import PromptBuilder
+from promptbuilder.llm_client.utils import inherited_decorator
+from promptbuilder.llm_client.exceptions import APIError
 
 
+P = ParamSpec("P")
+
 class BedrockApiKey(BaseModel, CustomApiKey):
     model_config = ConfigDict(frozen=True)
     
-    aws_access_key_id: str = os.getenv("AWS_ACCESS_KEY_ID")
-    aws_secret_access_key: str = os.getenv("AWS_SECRET_ACCESS_KEY")
-    aws_region: str = os.getenv("AWS_DEFAULT_REGION", "us-east-1")
+    aws_access_key_id: str
+    aws_secret_access_key: str
+    aws_region: str
+
 
+@inherited_decorator
+def _error_handler(func: Callable[P, Response]) -> Callable[P, Response]:
+    """
+    Decorator to catch error from boto libs and transform it into unified one
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except (Boto3Error, BotoCoreError, ClientError) as e:
+            code = None
+            response = None
+            status = None
+            response_json = {
+                "status": status,
+                "message": str(e.args),
+            }
+            raise APIError(code, response_json, response)
+    return wrapper
 
 class BedrockStreamIterator:
     def __init__(self, bedrock_iterator: EventStream):
@@ -51,13 +78,19 @@ class BedrockLLMClient(BaseLLMClient):
     def __init__(
         self,
         model: str,
-        api_key: BedrockApiKey = BedrockApiKey(),
+        api_key: BedrockApiKey | None = None,
         decorator_configs: DecoratorConfigs | None = None,
         default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
-        if api_key is None or not isinstance(api_key, BedrockApiKey):
+        if api_key is None:
+            api_key = BedrockApiKey(
+                aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+                aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+                aws_region=os.getenv("AWS_DEFAULT_REGION", "us-east-1"),
+            )
+        if not isinstance(api_key, BedrockApiKey):
             raise ValueError(
                 "To create a bedrock llm client you need to either set the environment variables "
                 "AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and optional AWS_DEFAULT_REGION or pass the api_key as BedrockApiKey instance"
@@ -69,6 +102,7 @@ class BedrockLLMClient(BaseLLMClient):
     def api_key(self) -> BedrockApiKey:
         return self._api_key
     
+    @_error_handler
     def create(
         self,
         messages: list[Content],
@@ -226,7 +260,8 @@ class BedrockLLMClient(BaseLLMClient):
                 ),
                 parsed=parsed_pydantic,
             )
-        
+    
+    @_error_handler
     def create_stream(
         self,
         messages: list[Content],
@@ -278,6 +313,27 @@ class BedrockLLMClient(BaseLLMClient):
             ))
         return models
 
+
+@inherited_decorator
+def _error_handler_async(func: Callable[P, Awaitable[Response]]) -> Callable[P, Awaitable[Response]]:
+    """
+    Decorator to catch error from boto libs and transform it into unified one
+    """
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except (Boto3Error, BotoCoreError, ClientError) as e:
+            code = None
+            response = None
+            status = None
+            response_json = {
+                "status": status,
+                "message": str(e.args),
+            }
+            raise APIError(code, response_json, response)
+    return wrapper
+
 class BedrockStreamIteratorAsync:
     def __init__(self, aioboto_session: aioboto3.Session, **bedrock_kwargs):
         self._aioboto_session = aioboto_session
@@ -313,13 +369,19 @@ class BedrockLLMClientAsync(BaseLLMClientAsync):
     def __init__(
         self,
         model: str,
-        api_key: BedrockApiKey = BedrockApiKey(),
+        api_key: BedrockApiKey | None = None,
         decorator_configs: DecoratorConfigs | None = None,
         default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
-        if api_key is None or not isinstance(api_key, BedrockApiKey):
+        if api_key is None:
+            api_key = BedrockApiKey(
+                aws_access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
+                aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+                aws_region=os.getenv("AWS_DEFAULT_REGION", "us-east-1"),
+            )
+        if not isinstance(api_key, BedrockApiKey):
             raise ValueError(
                 "To create a bedrock llm client you need to either set the environment variables "
                 "AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and optional AWS_DEFAULT_REGION or pass the api_key as BedrockApiKey instance"
@@ -336,6 +398,7 @@ class BedrockLLMClientAsync(BaseLLMClientAsync):
     def api_key(self) -> BedrockApiKey:
         return self._api_key
     
+    @_error_handler_async
     async def create(
         self,
         messages: list[Content],
@@ -487,7 +550,8 @@ class BedrockLLMClientAsync(BaseLLMClientAsync):
                     ),
                     parsed=parsed_pydantic,
                 )
-        
+    
+    @_error_handler_async
     async def create_stream(
         self,
         messages: list[Content],

promptbuilder/llm_client/exceptions.py

@@ -0,0 +1,128 @@
+import json
+from typing import Any
+
+import httpx
+import aiohttp
+
+
+class APIError(Exception):
+    """General errors raised by the llm clients"""
+    code: int | None = None
+    status: str | None = None
+    message: str | None = None
+    response: httpx.Response | aiohttp.ClientResponse | None = None
+
+    def __init__(self, code: int | None = None, response_json: dict[str, Any] = {}, response: httpx.Response | aiohttp.ClientResponse | None = None):
+        self.response = response
+        self.details = response_json
+        self.message = self._get_message(response_json)
+        self.status = self._get_status(response_json)
+        self.code = code if code else self._get_code(response_json)
+
+        super().__init__(f"{self.code} {self.status}. {self.details}")
+
+    def _get_status(self, response_json: dict[str, Any]) -> Any:
+        return response_json.get(
+            "status", response_json.get("error", {}).get("status", None)
+        )
+
+    def _get_message(self, response_json: dict[str, Any]) -> Any:
+        return response_json.get(
+            "message", response_json.get("error", {}).get("message", None)
+        )
+
+    def _get_code(self, response_json: dict[str, Any]) -> Any:
+        return response_json.get(
+            "code", response_json.get("error", {}).get("code", None)
+        )
+
+    def _to_replay_record(self) -> dict[str, Any]:
+        """Returns a dictionary representation of the error for replay recording."""
+        return {
+            "error": {
+                "code": self.code,
+                "message": self.message,
+                "status": self.status,
+            }
+        }
+
+    @classmethod
+    def raise_for_response(cls, response: httpx.Response):
+        """Raises an error with detailed error message if the response has an error status."""
+        if response.status_code == 200:
+            return
+
+        if isinstance(response, httpx.Response):
+            try:
+                response.read()
+                response_json = response.json()
+            except json.decoder.JSONDecodeError:
+                message = response.text
+                response_json = {
+                    "message": message,
+                    "status": response.reason_phrase,
+                }
+        else:
+            response_json = response.body_segments[0].get('error', {})
+
+        status_code = response.status_code
+        if 400 <= status_code < 500:
+            raise ClientError(status_code, response_json, response)
+        elif 500 <= status_code < 600:
+            raise ServerError(status_code, response_json, response)
+        else:
+            raise cls(status_code, response_json, response)
+
+    @classmethod
+    async def raise_for_async_response(cls, response: httpx.Response | aiohttp.ClientResponse):
+        """Raises an error with detailed error message if the response has an error status."""
+        status_code = 0
+        response_json = None
+        if isinstance(response, httpx.Response):
+            if response.status_code == 200:
+                return
+            try:
+                await response.aread()
+                response_json = response.json()
+            except json.decoder.JSONDecodeError:
+                message = response.text
+                response_json = {
+                    "message": message,
+                    "status": response.reason_phrase,
+                }
+            status_code = response.status_code
+        else:
+            try:
+                if isinstance(response, aiohttp.ClientResponse):
+                    if response.status == 200:
+                        return
+                    try:
+                        response_json = await response.json()
+                    except aiohttp.client_exceptions.ContentTypeError:
+                        message = await response.text()
+                        response_json = {
+                            "message": message,
+                            "status": response.reason,
+                        }
+                    status_code = response.status
+                else:
+                    response_json = response.body_segments[0].get("error", {})
+            except ImportError:
+                response_json = response.body_segments[0].get("error", {})
+
+        if 400 <= status_code < 500:
+            raise ClientError(status_code, response_json, response)
+        elif 500 <= status_code < 600:
+            raise ServerError(status_code, response_json, response)
+        else:
+            raise cls(status_code, response_json, response)
+
+
+class ClientError(APIError):
+    """Client error raised by the llm clients"""
+    pass
+
+
+class ServerError(APIError):
+    """Server error raised by the llm clients"""
+    pass

promptbuilder/llm_client/google_client.py

@@ -1,12 +1,42 @@
 import os
-from typing import AsyncIterator, Iterator
+from functools import wraps
+from typing import AsyncIterator, Iterator, Callable, ParamSpec, Awaitable
 
 from pydantic import BaseModel
+from tenacity import RetryError
 from google.genai import Client, types
 
 from promptbuilder.llm_client.base_client import BaseLLMClient, BaseLLMClientAsync, ResultType
 from promptbuilder.llm_client.types import Response, Content, Part, ThinkingConfig, Tool, ToolConfig, Model
 from promptbuilder.llm_client.config import DecoratorConfigs
+from promptbuilder.llm_client.utils import inherited_decorator
+from promptbuilder.llm_client.exceptions import APIError
+
+
+P = ParamSpec("P")
+
+
+@inherited_decorator
+def _error_handler(func: Callable[P, Response]) -> Callable[P, Response]:
+    """
+    Decorator to catch error from google.genai and transform it into unified one
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except RetryError as retry_error:
+            e = retry_error.last_attempt._exception
+            if e is None:
+                raise APIError()
+            code = e.code
+            response_json = {
+                "status": e.status,
+                "message": e.message,
+            }
+            response = e.response
+            raise APIError(code, response_json, response)
+    return wrapper
 
 
 class GoogleLLMClient(BaseLLMClient):
@@ -15,12 +45,14 @@ class GoogleLLMClient(BaseLLMClient):
     def __init__(
         self,
         model: str,
-        api_key: str = os.getenv("GOOGLE_API_KEY"),
+        api_key: str | None = None,
         decorator_configs: DecoratorConfigs | None = None,
         default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
+        if api_key is None:
+            api_key = os.getenv("GOOGLE_API_KEY")
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create a google llm client you need to either set the environment variable GOOGLE_API_KEY or pass the api_key in string format")
         super().__init__(GoogleLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
@@ -53,7 +85,8 @@ class GoogleLLMClient(BaseLLMClient):
             )
             new_messages.append(new_message)
         return new_messages
-        
+    
+    @_error_handler
     def create(
         self,
         messages: list[Content],
@@ -103,7 +136,8 @@ class GoogleLLMClient(BaseLLMClient):
             )
         else:
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
-        
+    
+    @_error_handler
     def create_stream(
         self,
         messages: list[Content],
@@ -159,18 +193,42 @@ class GoogleLLMClient(BaseLLMClient):
         return models
 
 
+@inherited_decorator
+def _error_handler_async(func: Callable[P, Awaitable[Response]]) -> Callable[P, Awaitable[Response]]:
+    """
+    Decorator to catch error from google.genai and transform it into unified one
+    """
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except RetryError as retry_error:
+            e = retry_error.last_attempt._exception
+            if e is None:
+                raise APIError()
+            code = e.code
+            response_json = {
+                "status": e.status,
+                "message": e.message,
+            }
+            response = e.response
+            raise APIError(code, response_json, response)
+    return wrapper
+
 class GoogleLLMClientAsync(BaseLLMClientAsync):
     PROVIDER: str = "google"
     
     def __init__(
         self,
         model: str,
-        api_key: str = os.getenv("GOOGLE_API_KEY"),
+        api_key: str | None = None,
         decorator_configs: DecoratorConfigs | None = None,
         default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
+        if api_key is None:
+            api_key = os.getenv("GOOGLE_API_KEY")
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create a google llm client you need to either set the environment variable GOOGLE_API_KEY or pass the api_key in string format")
         super().__init__(GoogleLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
@@ -181,6 +239,7 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
     def api_key(self) -> str:
         return self._api_key
 
+    @_error_handler_async
     async def create(
         self,
         messages: list[Content],
@@ -222,7 +281,8 @@ class GoogleLLMClientAsync(BaseLLMClientAsync):
             )
         else:
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
-        
+    
+    @_error_handler_async
     async def create_stream(
         self,
         messages: list[Content],

promptbuilder/llm_client/main.py

@@ -40,10 +40,7 @@ def get_client(
     provider, model = full_model_name.split(":", 1)
     if provider in provider_to_client_class:
         client_class = provider_to_client_class[provider]
-        if api_key is None:
-            client = client_class(model, **kwargs)
-        else:
-            client = client_class(model, api_key, **kwargs)
+        client = client_class(model, api_key, **kwargs)
     else:
         if api_key is None:
             raise ValueError(f"You should directly provide api_key for this provider: {provider}")
@@ -87,10 +84,7 @@ def get_async_client(
     provider, model = full_model_name.split(":", 1)
     if provider in provider_to_client_class:
         client_class = provider_to_client_class[provider]
-        if api_key is None:
-            client = client_class(model, **kwargs)
-        else:
-            client = client_class(model, api_key, **kwargs)
+        client = client_class(model, api_key, **kwargs)
     else:
         if api_key is None:
             raise ValueError(f"You should directly provide api_key for this provider: {provider}")

promptbuilder/llm_client/openai_client.py

@@ -1,17 +1,43 @@
 import os
 import json
 import base64
-from typing import AsyncIterator, Iterator
+from functools import wraps
+from typing import AsyncIterator, Iterator, Callable, ParamSpec, Awaitable
 
 from pydantic import BaseModel
-from openai import OpenAI, AsyncOpenAI, Stream, AsyncStream
+from openai import OpenAI, AsyncOpenAI, Stream, AsyncStream, APIError as OpenAIAPIError
 from openai.types.responses import ResponseStreamEvent
 
 from promptbuilder.llm_client.base_client import BaseLLMClient, BaseLLMClientAsync, ResultType
 from promptbuilder.llm_client.types import Response, Content, Candidate, UsageMetadata, Part, ThinkingConfig, Tool, ToolConfig, FunctionCall, MessageDict, Model
 from promptbuilder.llm_client.config import DecoratorConfigs
+from promptbuilder.llm_client.utils import inherited_decorator
+from promptbuilder.llm_client.exceptions import APIError
 
 
+P = ParamSpec("P")
+
+
+@inherited_decorator
+def _error_handler(func: Callable[P, Response]) -> Callable[P, Response]:
+    """
+    Decorator to catch error from openai and transform it into unified one
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except OpenAIAPIError as e:
+            code = getattr(e, "status_code", None) or e.code
+            response = getattr(e, "response", None)
+            status = getattr(response, "reason_phrase", None)
+            response_json = {
+                "status": status,
+                "message": e.message,
+            }
+            raise APIError(code, response_json, response)
+    return wrapper
+
 class OpenaiStreamIterator:
     def __init__(self, openai_iterator: Stream[ResponseStreamEvent]):
         self._openai_iterator = openai_iterator
@@ -43,12 +69,14 @@ class OpenaiLLMClient(BaseLLMClient):
     def __init__(
         self,
         model: str,
-        api_key: str = os.getenv("OPENAI_API_KEY"),
+        api_key: str | None = None,
         decorator_configs: DecoratorConfigs | None = None,
         default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
+        if api_key is None:
+            api_key = os.getenv("OPENAI_API_KEY")
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create an openai llm client you need to either set the environment variable OPENAI_API_KEY or pass the api_key in string format")
         super().__init__(OpenaiLLMClient.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
@@ -113,6 +141,7 @@ class OpenaiLLMClient(BaseLLMClient):
                     openai_thinking_config["reasoning"] = {"effort": "high"}
         return openai_thinking_config
 
+    @_error_handler
     def create(
         self,
         messages: list[Content],
@@ -223,7 +252,8 @@ class OpenaiLLMClient(BaseLLMClient):
             )
         else:
             raise ValueError(f"Unsupported result type: {result_type}. Supported types are None, 'json', or a Pydantic model class.")
-        
+    
+    @_error_handler
     def create_stream(
         self,
         messages: list[Content],
@@ -277,6 +307,26 @@ class OpenaiLLMClient(BaseLLMClient):
         return models
 
 
+@inherited_decorator
+def _error_handler_async(func: Callable[P, Awaitable[Response]]) -> Callable[P, Awaitable[Response]]:
+    """
+    Decorator to catch error from openai and transform it into unified one
+    """
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except OpenAIAPIError as e:
+            code = getattr(e, "status_code", None) or e.code
+            response = getattr(e, "response", None)
+            status = getattr(response, "reason_phrase", None)
+            response_json = {
+                "status": status,
+                "message": e.message,
+            }
+            raise APIError(code, response_json, response)
+    return wrapper
+
 class OpenaiStreamIteratorAsync:
     def __init__(self, openai_iterator: AsyncStream[ResponseStreamEvent]):
         self._openai_iterator = openai_iterator
@@ -308,12 +358,14 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
     def __init__(
         self,
         model: str,
-        api_key: str = os.getenv("OPENAI_API_KEY"),
+        api_key: str | None = None,
         decorator_configs: DecoratorConfigs | None = None,
         default_thinking_config: ThinkingConfig | None = None,
         default_max_tokens: int | None = None,
         **kwargs,
     ):
+        if api_key is None:
+            api_key = os.getenv("OPENAI_API_KEY")
         if api_key is None or not isinstance(api_key, str):
             raise ValueError("To create an openai llm client you need to either set the environment variable OPENAI_API_KEY or pass the api_key in string format")
         super().__init__(OpenaiLLMClientAsync.PROVIDER, model, decorator_configs=decorator_configs, default_thinking_config=default_thinking_config, default_max_tokens=default_max_tokens)
@@ -324,6 +376,7 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
     def api_key(self) -> str:
         return self._api_key
     
+    @_error_handler_async
     async def create(
         self,
         messages: list[Content],
@@ -441,7 +494,8 @@ class OpenaiLLMClientAsync(BaseLLMClientAsync):
             )
         else:
             raise ValueError(f"Unsupported result_type: {result_type}. Supported types are: None, 'json', or a Pydantic model.")
-        
+    
+    @_error_handler_async
     async def create_stream(
         self,
         messages: list[Content],

{promptbuilder-0.4.19.dist-info → promptbuilder-0.4.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: promptbuilder
-Version: 0.4.19
+Version: 0.4.21
 Summary: Library for building prompts for LLMs
 Home-page: https://github.com/kapulkin/promptbuilder
 Author: Kapulkin Stanislav

{promptbuilder-0.4.19.dist-info → promptbuilder-0.4.21.dist-info}/RECORD

@@ -6,20 +6,21 @@ promptbuilder/agent/agent.py,sha256=dVu251C1r9w5LS2P_shsIRH9tFz1Jq93MDv3Uu41_4E,
 promptbuilder/agent/context.py,sha256=CVw715vFrhfvddQmRNy4A1U87GsZyIKj9Xu4SCidbc0,1120
 promptbuilder/agent/tool.py,sha256=VDbIHK3_Q62Ei7hwLF7nIgHq-PTMKnv1NSjHpDYkUZE,2651
 promptbuilder/agent/utils.py,sha256=vTkphKw04v_QDIJtoB2JKK0RGY6iI1t_0LbmuStunzI,356
-promptbuilder/llm_client/__init__.py,sha256=2tPVYqwNdwTRdIg4Pde6Nc259FJvy70gjEj1N2oqNrc,458
+promptbuilder/llm_client/__init__.py,sha256=wJ33cnRtZX_YPsbcGxEu3SEZMOhPX7-fHI59MEPUe7I,517
 promptbuilder/llm_client/aisuite_client.py,sha256=aMqg05zefzck9Lz7pm7jZoKFdzr_ymFYhrAjZtzdHlQ,15561
-promptbuilder/llm_client/anthropic_client.py,sha256=JeTVC26ahuJJT4G_3Bsoc4TqLzVDPuJpJiCRxTALnqA,26146
+promptbuilder/llm_client/anthropic_client.py,sha256=vWuyFZL_LohOE0UYjB1-zTr4tJZMUcGk8H10gpjzdkk,28074
 promptbuilder/llm_client/base_client.py,sha256=GS-Qb20WtZnljmEUD2ibhTHDet7exoyhQ0_mGNAEKlg,24219
-promptbuilder/llm_client/bedrock_client.py,sha256=W4wFW7Vbv-nsT2ReyhJ4YIPSTXxE_4S83352vJDSmDk,25772
+promptbuilder/llm_client/bedrock_client.py,sha256=e9vUClbybQb32028oDBW6IbyPYqj1ZSSv9y36ZqUWxM,27941
 promptbuilder/llm_client/config.py,sha256=exQEm35wp7lK5SfXNpN5H9VZEb2LVa4pyZ-cxGt1U-U,1124
-promptbuilder/llm_client/google_client.py,sha256=heyeACt_0bVP3p4pCQeWR92MhCsyNk844kWJ_0MVTfg,9830
+promptbuilder/llm_client/exceptions.py,sha256=t-X7r_a8B1jNu8eEavde1jXu5dz97yV3IG4YHOtgh0Y,4836
+promptbuilder/llm_client/google_client.py,sha256=y1_CFXBijUiRTyAJsh-8a6CGIwwlZBskO5kWqVWZcPo,11780
 promptbuilder/llm_client/logfire_decorators.py,sha256=un_QnIekypOEcqTZ5v1y9pwijGnF95xwnwKO5rFSHVY,9667
-promptbuilder/llm_client/main.py,sha256=k4JTyKq2atNyFtI1bjjqXEnGSEugj4xk0AJEvHJiMig,8310
-promptbuilder/llm_client/openai_client.py,sha256=5yvjp-Zzp4JsBC9_ffSb1A9-iMG4Lu2B2et2CdtK9R0,22864
+promptbuilder/llm_client/main.py,sha256=5r_MhKVTD4cS90AHR89JJRKiWYBk35Y3JvhvmOxkYHc,8110
+promptbuilder/llm_client/openai_client.py,sha256=GdyTbUPsbACXZYF0BnCRyLVw24_WM1R_MMr6pDpiiV4,24787
 promptbuilder/llm_client/types.py,sha256=2E-aPRb5uAkLFJocmjF1Lh2aQRq9r8a5JRIw-duHfjA,7460
 promptbuilder/llm_client/utils.py,sha256=79lvSppjrrItHB5MIozbp_5Oq7TsOK4Qzt9Ae3XMLFw,7624
-promptbuilder-0.4.19.dist-info/licenses/LICENSE,sha256=fqXmInzgsvEOIaKSBgcrwKyYCGYF0MKErJ0YivtODcc,1096
-promptbuilder-0.4.19.dist-info/METADATA,sha256=H7BlzTYhhJi7NGunmjiYhaUqWAhWS-6ELC682S14VKY,3738
-promptbuilder-0.4.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-promptbuilder-0.4.19.dist-info/top_level.txt,sha256=UBVcYn4UgrPy3O3fmmnPEU_kieuplBMgheetIMei4EI,14
-promptbuilder-0.4.19.dist-info/RECORD,,
+promptbuilder-0.4.21.dist-info/licenses/LICENSE,sha256=fqXmInzgsvEOIaKSBgcrwKyYCGYF0MKErJ0YivtODcc,1096
+promptbuilder-0.4.21.dist-info/METADATA,sha256=A44iObCMOJxcKjF6fYxU-O-QugjMPrgkJJJDu2Rm4Vc,3738
+promptbuilder-0.4.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+promptbuilder-0.4.21.dist-info/top_level.txt,sha256=UBVcYn4UgrPy3O3fmmnPEU_kieuplBMgheetIMei4EI,14
+promptbuilder-0.4.21.dist-info/RECORD,,