promptbuilder 0.4.18__py3-none-any.whl → 0.4.20__py3-none-any.whl

promptbuilder/embeddings.py

@@ -0,0 +1,206 @@
+import os
+import asyncio
+from copy import deepcopy
+from typing import Literal, get_args
+
+import numpy as np
+from google import genai
+from google.genai.types import EmbedContentConfig, EmbedContentResponse
+from openai import AsyncOpenAI
+
+import promptbuilder.llm_client.utils as utils
+
+
+type EMBS_TASK_TYPE = Literal["RETRIEVAL_QUERY", "RETRIEVAL_DOCUMENT", "SEMANTIC_SIMILARITY"]
+type EMBEDDING = list[float]
+EMBS_TASKS = get_args(EMBS_TASK_TYPE)
+
+
+def normalize_embeddings(embs: list[list[float]] | list[float]) -> list[list[float]] | list[float]:
+    embs_np = np.array(embs)
+    emb_norms = np.sqrt(np.sum(embs_np * embs_np, axis=-1, keepdims=True))
+    embs_np = embs_np / emb_norms
+    return embs_np.tolist()
+
+
+class EmbeddingsApi(utils.InheritDecoratorsMixin):
+    available_model_dims: dict[str, list[int]] = {}
+    default_model_dim: dict[str, int] = {}
+    model_name_prefix: str = ""
+    
+    def __init__(self, model_name: str, embs_dim: int | None = None, *args, retry_times: int = 0, retry_delay: float = 0, **kwargs):
+        if model_name not in self.available_model_dims:
+            raise ValueError(f"Model {model_name} is not supported.")
+        if embs_dim is None:
+            embs_dim = self.default_model_dim[model_name]
+        else:
+            if embs_dim not in self.available_model_dims[model_name]:
+                raise ValueError(f"Model {model_name} does not support embedding dimension {embs_dim}.")
+        
+        self._model_name = model_name
+        self._embs_dim = embs_dim
+        self._retry_times = retry_times
+        self._retry_delay = retry_delay
+    
+    @property
+    def embeddings_dim(self) -> int:
+        return self._embs_dim
+
+    @property
+    def model_name(self) -> str:
+        return self.model_name_prefix + self._model_name
+    
+    @utils.retry_cls_async
+    async def get_embeddings(
+        self,
+        texts: list[str] | str,
+        task_types: list[EMBS_TASK_TYPE] | EMBS_TASK_TYPE = ["SEMANTIC_SIMILARITY"],
+        normalize: bool = True,
+    ) -> dict[EMBS_TASK_TYPE, list[EMBEDDING]] | dict[EMBS_TASK_TYPE, EMBEDDING] | list[EMBEDDING] | EMBEDDING:
+        pass
+
+
+class GoogleEmbsApi(EmbeddingsApi):
+    available_model_dims: dict[str, list[int]] = {"text-embedding-004": [768]}
+    default_model_dim: dict[str, int] = {"text-embedding-004": 768}
+    model_name_prefix: str = "google:"
+    
+    def __init__(
+        self,
+        model_name: str = "text-embedding-004",
+        embs_dim: int | None = None,
+        *,
+        retry_times: int = 0,
+        retry_delay: float = 0,
+        **kwargs,
+    ):
+        super().__init__(model_name, embs_dim, retry_times=retry_times, retry_delay=retry_delay)
+        self._client = genai.Client(api_key=os.getenv("GOOGLEAI_API_KEY"))
+        self._rpm_limit = 145
+    
+    async def get_embeddings(
+        self,
+        texts: list[str] | str,
+        task_types: list[EMBS_TASK_TYPE] | EMBS_TASK_TYPE = ["SEMANTIC_SIMILARITY"],
+        normalize: bool = True,
+        **kwargs,
+    ) -> dict[EMBS_TASK_TYPE, list[EMBEDDING]] | dict[EMBS_TASK_TYPE, EMBEDDING] | list[EMBEDDING] | EMBEDDING:
+        batch_size = 10
+        
+        if isinstance(task_types, list):
+            task_types = list(set(task_types))
+            embeddings = await asyncio.gather(*[self.get_embeddings(texts, task_type, normalize) for task_type in task_types])
+            response = {task_type: embs for task_type, embs in zip(task_types, embeddings)}
+            return response
+        
+        task_type = task_types
+        if isinstance(texts, str):
+            response = await self._api_request(
+                model=self._model_name,
+                contents=texts,
+                config=EmbedContentConfig(task_type=task_type),
+            )
+            if normalize:
+                return normalize_embeddings(response.embeddings[0].values)
+            else:
+                return response.embeddings[0].values
+        elif isinstance(texts, list):
+            batches_num = len(texts) // batch_size + 1
+            result_embeddings: list[list[float]] = []
+            
+            for i in range(batches_num):
+                first_idx = i * batch_size
+                last_idx = (i + 1) * batch_size
+                batch = texts[first_idx: last_idx]
+                if len(batch) > 0:
+                    response = await self._api_request(
+                        model=self._model_name,
+                        contents=batch,
+                        config=EmbedContentConfig(task_type=task_type),
+                    )
+                    result_embeddings += [embeddings.values for embeddings in response.embeddings]
+            
+            if normalize:
+                return normalize_embeddings(result_embeddings)
+            else:
+                return result_embeddings
+        else:
+            raise ValueError("'texts' must be a string or a list of strings.")
+    
+    @utils.rpm_limit_cls_async
+    async def _api_request(self, model: str, contents: str | list[str], config: EmbedContentConfig) -> EmbedContentResponse:
+        return await self._client.aio.models.embed_content(
+            model=model,
+            contents=contents,
+            config=config,
+        )
+
+
+class OpenAIEmbsApi(EmbeddingsApi):
+    available_model_dims: dict[str, list[int]] = {
+        "text-embedding-3-small": [512, 1536],
+        "text-embedding-3-large": [1024, 3072],
+    }
+    default_model_dim: dict[str, int] = {
+        "text-embedding-3-small": 1536,
+        "text-embedding-3-large": 3072,
+    }
+    model_name_prefix: str = "openai:"
+    
+    def __init__(
+        self,
+        model_name: str = "text-embedding-3-small",
+        embs_dim: int | None = None,
+        *,
+        retry_times: int = 0,
+        retry_delay: float = 0,
+        **kwargs,
+    ):
+        super().__init__(model_name, embs_dim, retry_times=retry_times, retry_delay=retry_delay)
+        self._client = AsyncOpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+    
+    async def get_embeddings(
+        self,
+        texts: list[str] | str,
+        task_types: list[EMBS_TASK_TYPE] | EMBS_TASK_TYPE = ["SEMANTIC_SIMILARITY"],
+        normalize: bool = True,
+        **kwargs,
+    ) -> dict[EMBS_TASK_TYPE, list[EMBEDDING]] | dict[EMBS_TASK_TYPE, EMBEDDING] | list[EMBEDDING] | EMBEDDING:
+        if isinstance(task_types, list):
+            task_types = list(set(task_types))
+            embeddings = await self.get_embeddings(texts, "SEMANTIC_SIMILARITY", normalize)
+            response = {task_type: deepcopy(embeddings) for task_type in task_types}
+            return response
+        
+        if isinstance(texts, str):
+            response = await self._client.embeddings.create(
+                input=texts,
+                model=self._model_name,
+                dimensions=self._embs_dim,
+            )
+            if normalize:
+                return normalize_embeddings(response.data[0].embedding)
+            else:
+                return response.data[0].embedding
+        elif isinstance(texts, list):
+            batches_num = len(texts) // 100 + 1
+            result_embeddings = []
+            
+            for i in range(batches_num):
+                first_idx = i * 100
+                last_idx = (i + 1) * 100
+                batch = texts[first_idx: last_idx]
+                if len(batch) > 0:
+                    response = await self._client.embeddings.create(
+                        input=texts,
+                        model=self._model_name,
+                        dimensions=self._embs_dim,
+                    )
+                    result_embeddings += [emb.embedding for emb in response.data]
+            
+            if normalize:
+                return normalize_embeddings(result_embeddings)
+            else:
+                return result_embeddings
+        else:
+            raise ValueError("'texts' must be a string or a list of strings.")

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
@@ -162,6 +189,7 @@ class AnthropicLLMClient(BaseLLMClient):
                 anthropic_messages.append({"role": role, "content": content})
         return anthropic_messages
 
+    @_error_handler
     def create(
         self,
         messages: list[Content],
@@ -278,6 +306,7 @@ class AnthropicLLMClient(BaseLLMClient):
         else:
             raise ValueError(f"Unsupported result type: {result_type}")
     
+    @_error_handler
     def create_stream(
         self,
         messages: list[Content],
@@ -334,6 +363,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
@@ -391,6 +440,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 +563,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,17 +1,24 @@
 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)
     
@@ -20,6 +27,26 @@ class BedrockApiKey(BaseModel, CustomApiKey):
     aws_region: str = os.getenv("AWS_DEFAULT_REGION", "us-east-1")
 
 
+@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):
         self._bedrock_iterator = bedrock_iterator
@@ -69,6 +96,7 @@ class BedrockLLMClient(BaseLLMClient):
     def api_key(self) -> BedrockApiKey:
         return self._api_key
     
+    @_error_handler
     def create(
         self,
         messages: list[Content],
@@ -226,7 +254,8 @@ class BedrockLLMClient(BaseLLMClient):
                 ),
                 parsed=parsed_pydantic,
             )
-        
+    
+    @_error_handler
     def create_stream(
         self,
         messages: list[Content],
@@ -278,6 +307,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
@@ -336,6 +386,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 +538,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):
@@ -53,7 +83,8 @@ class GoogleLLMClient(BaseLLMClient):
             )
             new_messages.append(new_message)
         return new_messages
-        
+    
+    @_error_handler
     def create(
         self,
         messages: list[Content],
@@ -103,7 +134,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,6 +191,28 @@ 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"
     
@@ -181,6 +235,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 +277,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/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
@@ -113,6 +139,7 @@ class OpenaiLLMClient(BaseLLMClient):
                     openai_thinking_config["reasoning"] = {"effort": "high"}
         return openai_thinking_config
 
+    @_error_handler
     def create(
         self,
         messages: list[Content],
@@ -223,7 +250,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 +305,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
@@ -324,6 +372,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 +490,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.18.dist-info → promptbuilder-0.4.20.dist-info}/METADATA

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

{promptbuilder-0.4.18.dist-info → promptbuilder-0.4.20.dist-info}/RECORD

@@ -1,24 +1,26 @@
 promptbuilder/__init__.py,sha256=o_NdXl7NppM399-fy5VGfYkSN8iYDAaFAwJNhdkW3bI,56
+promptbuilder/embeddings.py,sha256=bu-soCNYiHxshc1jejGmI5iJTIdotqEhmvpImSjlFTY,8087
 promptbuilder/prompt_builder.py,sha256=kK6WHr2umYmsanYb2fQVxqEajs_dzGPXRulTo40g36E,12428
 promptbuilder/agent/__init__.py,sha256=qG4Jq4wbmCH5NKLOX6ZMtZ7lFURhJXf464BntR-u5rU,56
 promptbuilder/agent/agent.py,sha256=dVu251C1r9w5LS2P_shsIRH9tFz1Jq93MDv3Uu41_4E,9274
 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=ypr-KqlQJXHlGzwdSNYy9jH69mUQGUWIEhVkVHrtaro,27946
 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=FlUVF4YEzX7JzL4hEFQtNSLSQwPOilnN8unqRgHE4M8,27508
 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=5AucfhCM32Sd2c3vr8oPNNwrVSSrZ9EgzIIVlIHx00U,11652
 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/openai_client.py,sha256=Mtd5Y5Bt-KgtyYPSXXCt-0ZiXN4_B0Rfya1EPxqNuaQ,24659
 promptbuilder/llm_client/types.py,sha256=2E-aPRb5uAkLFJocmjF1Lh2aQRq9r8a5JRIw-duHfjA,7460
 promptbuilder/llm_client/utils.py,sha256=79lvSppjrrItHB5MIozbp_5Oq7TsOK4Qzt9Ae3XMLFw,7624
-promptbuilder-0.4.18.dist-info/licenses/LICENSE,sha256=fqXmInzgsvEOIaKSBgcrwKyYCGYF0MKErJ0YivtODcc,1096
-promptbuilder-0.4.18.dist-info/METADATA,sha256=bbynjS91gKgHZKKCzw1VgD2FgI54Orn5OLRUqZJsQmA,3738
-promptbuilder-0.4.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-promptbuilder-0.4.18.dist-info/top_level.txt,sha256=UBVcYn4UgrPy3O3fmmnPEU_kieuplBMgheetIMei4EI,14
-promptbuilder-0.4.18.dist-info/RECORD,,
+promptbuilder-0.4.20.dist-info/licenses/LICENSE,sha256=fqXmInzgsvEOIaKSBgcrwKyYCGYF0MKErJ0YivtODcc,1096
+promptbuilder-0.4.20.dist-info/METADATA,sha256=L4GN9TJv_sCOtJTelH1AC8bINLY66oXoBAh38lhgpKU,3738
+promptbuilder-0.4.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+promptbuilder-0.4.20.dist-info/top_level.txt,sha256=UBVcYn4UgrPy3O3fmmnPEU_kieuplBMgheetIMei4EI,14
+promptbuilder-0.4.20.dist-info/RECORD,,