unique_toolkit 2026.44.0.dev9__tar.gz → 2026.44.1__tar.gz

{unique_toolkit-2026.44.0.dev9 → unique_toolkit-2026.44.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.44.0.dev9
+Version: 2026.44.1
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>
@@ -16,7 +16,7 @@ Requires-Dist: sseclient>=0.0.27,<0.0.28
 Requires-Dist: openai>=1.105.0,<3
 Requires-Dist: platformdirs>=4.0.0,<5
 Requires-Dist: pillow>=12.1.1
-Requires-Dist: unique-sdk>=2026.44.0.dev13,<2026.44.0rc0
+Requires-Dist: unique-sdk>=2026.44.1
 Requires-Dist: jambo>=0.1.2,<0.2
 Requires-Dist: jinja2>=3.1.6,<4
 Requires-Dist: docxtpl>=0.20.1,<0.21

{unique_toolkit-2026.44.0.dev9 → unique_toolkit-2026.44.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.44.0.dev9"
+version = "2026.44.1"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"
@@ -28,7 +28,7 @@ dependencies = [
     "openai>=1.105.0,<3",
     "platformdirs>=4.0.0,<5",
     "pillow>=12.1.1",
-    "unique-sdk>=2026.44.0.dev13,<2026.44.0rc0",
+    "unique-sdk>=2026.44.1",
     "jambo>=0.1.2,<0.2",
     "jinja2>=3.1.6,<4",
     "docxtpl>=0.20.1,<0.21",

{unique_toolkit-2026.44.0.dev9 → unique_toolkit-2026.44.1}/unique_toolkit/chat/functions.py

@@ -35,6 +35,9 @@ from unique_toolkit.language_model.constants import (
     DEFAULT_COMPLETE_TEMPERATURE,
     DEFAULT_COMPLETE_TIMEOUT,
 )
+from unique_toolkit.language_model.errors import (
+    _reraise_as_language_model_call_error,
+)
 from unique_toolkit.language_model.functions import (
     _prepare_all_completions_params_util,
 )
@@ -954,7 +957,7 @@ def stream_complete_with_references(
         return LanguageModelStreamResponse(**response)
     except Exception as e:
         _LOGGER.error(f"Error streaming completion: {e}")
-        raise e
+        _reraise_as_language_model_call_error(e)
 
 
 @deprecated("Use stream_complete_with_references_async instead")
@@ -1051,7 +1054,7 @@ async def stream_complete_with_references_async(
         return LanguageModelStreamResponse(**response)
     except Exception as e:
         _LOGGER.error(f"Error streaming completion: {e}")
-        raise e
+        _reraise_as_language_model_call_error(e)
 
 
 def _get_model_dump_or_none(model: BaseModel | None) -> dict[str, Any] | None:

{unique_toolkit-2026.44.0.dev9 → unique_toolkit-2026.44.1}/unique_toolkit/chat/responses_api.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import random
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Mapping
 from typing import Any, NamedTuple, Sequence
 
 import unique_sdk
@@ -30,6 +30,9 @@ from unique_toolkit.content.schemas import ContentChunk
 from unique_toolkit.language_model.constants import (
     DEFAULT_COMPLETE_TEMPERATURE,
 )
+from unique_toolkit.language_model.errors import (
+    _reraise_as_language_model_call_error,
+)
 from unique_toolkit.language_model.functions import (
     SearchContext,
     _to_search_context,
@@ -407,8 +410,26 @@ class RateLimitRetryConfig(BaseSettings):
 rate_limit_retry_config = RateLimitRetryConfig()
 
 
+def _retry_after_seconds(exc: BaseException | None) -> float | None:
+    params = getattr(exc, "params", None)
+    if not isinstance(params, Mapping):
+        return None
+    retry_after = params.get("retryAfterSeconds")
+    if (
+        isinstance(retry_after, (int, float))
+        and not isinstance(retry_after, bool)
+        and retry_after >= 0
+    ):
+        return float(retry_after)
+    return None
+
+
 def _rate_limit_wait(retry_state: RetryCallState) -> float:
-    """Exponential backoff with up to 10% jitter: initial_delay → 2x → 4x."""
+    """Wait ``retryAfterSeconds`` when the API sent one, else exponential backoff."""
+    exc = retry_state.outcome.exception() if retry_state.outcome else None
+    retry_after = _retry_after_seconds(exc)
+    if retry_after is not None:
+        return retry_after
     n = retry_state.attempt_number - 1  # 0-indexed
     base = rate_limit_retry_config.initial_delay_seconds * (2.0**n)
     return base + random.uniform(0.0, base * 0.1)
@@ -421,9 +442,8 @@ async def _responses_stream_with_rate_limit_retry(
 ) -> "unique_sdk.Integrated.ResponsesStreamResult":
     """Wrap responses_stream_async with exponential backoff for rate-limit errors.
 
-    The SDK already retries 3× (1s/2s/4s) before raising. This layer adds further
-    retries with longer delays, which are needed for models with tighter RPM limits
-    (e.g. GPT-4o) when large-token requests (web search, code execution) are in the loop.
+    The SDK does not retry 429s. This layer retries a retryable ``RateLimitError``,
+    waiting ``params.retryAfterSeconds`` when the API sent one.
 
     Args:
         responses_args: Keyword arguments forwarded to responses_stream_async.
@@ -434,6 +454,11 @@ async def _responses_stream_with_rate_limit_retry(
     """
 
     def _is_rate_limit(exc: BaseException) -> bool:
+        if isinstance(exc, unique_sdk.RateLimitError):
+            params = getattr(exc, "params", None)
+            if isinstance(params, Mapping) and params.get("retryable") is False:
+                return False
+            return True
         return isinstance(exc, unique_sdk.APIError) and any(
             kw in str(exc).lower() for kw in _RATE_LIMIT_KEYWORDS
         )
@@ -539,11 +564,11 @@ def stream_responses_with_references(
         other_options=other_options,
     )
 
-    return ResponsesLanguageModelStreamResponse.model_validate(
-        unique_sdk.Integrated.responses_stream(
-            **responses_args,
-        )
-    )
+    try:
+        streamed = unique_sdk.Integrated.responses_stream(**responses_args)
+    except unique_sdk.UniqueError as error:
+        _reraise_as_language_model_call_error(error)
+    return ResponsesLanguageModelStreamResponse.model_validate(streamed)
 
 
 async def stream_responses_with_references_async(
@@ -608,10 +633,12 @@ async def stream_responses_with_references_async(
         "Calling responses_stream_async model=%s",
         responses_params.model_name,
     )
-    return ResponsesLanguageModelStreamResponse.model_validate(
-        await _responses_stream_with_rate_limit_retry(
+    try:
+        streamed = await _responses_stream_with_rate_limit_retry(
             responses_args=responses_args,
             model_name=responses_params.model_name,
             on_rate_limit_retry=on_rate_limit_retry,
         )
-    )
+    except unique_sdk.UniqueError as error:
+        _reraise_as_language_model_call_error(error)
+    return ResponsesLanguageModelStreamResponse.model_validate(streamed)

{unique_toolkit-2026.44.0.dev9 → unique_toolkit-2026.44.1}/unique_toolkit/language_model/__init__.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING, Any
 
 from .constants import DOMAIN_NAME
 from .default_language_model import DEFAULT_LANGUAGE_MODEL, DEFAULT_GPT_4o
+from .errors import LanguageModelCallError as LanguageModelCallError
 from .functions import (
     stream_complete_with_references_openai as stream_complete_with_references_openai,
 )
@@ -59,6 +60,7 @@ def __getattr__(name: str) -> Any:
 
 __all__ = [
     "LanguageModel",
+    "LanguageModelCallError",
     "LanguageModelName",
     "Prompt",
     "LanguageModelAssistantMessage",

unique_toolkit-2026.44.1/unique_toolkit/language_model/errors.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import NoReturn
+
+import unique_sdk
+
+
+class LanguageModelCallError(unique_sdk.APIError):
+    """LLM call rejected with node-chat's error contract.
+
+    ``user_message`` is the text the API curated for the user. Display that
+    field. ``str(self)`` is the same text, without the SDK's
+    ``(Original error)`` suffix.
+
+    It subclasses ``APIError`` so callers that catch the SDK error around
+    toolkit calls keep catching it.
+
+    Args:
+        code (str): ``error.code`` from the API, for example ``content_filter``.
+        user_message (str): Text to show the user.
+        retryable (bool): Whether the API marked the call safe to retry.
+        correlation_id (str | None): Request correlation id, when the API sent one.
+        http_status (int | None): HTTP status of the failed call.
+    """
+
+    def __init__(
+        self,
+        *,
+        code: str,
+        user_message: str,
+        retryable: bool,
+        correlation_id: str | None,
+        http_status: int | None = None,
+    ) -> None:
+        super().__init__(message=user_message, http_status=http_status, code=code)
+        self.user_message = user_message
+        self.retryable = retryable
+        self.correlation_id = correlation_id
+
+
+def _language_model_call_error_from(
+    error: unique_sdk.UniqueError,
+) -> LanguageModelCallError | None:
+    """Build a ``LanguageModelCallError`` when ``error`` carries the contract.
+
+    Returns None for legacy SDK errors that have no ``code`` or no boolean
+    ``params.retryable``. Callers re-raise those unchanged.
+
+    Args:
+        error (unique_sdk.UniqueError): Error raised by ``unique_sdk``.
+
+    Returns:
+        LanguageModelCallError | None: The converted error, or None.
+    """
+    if not isinstance(error.code, str) or error.code == "":
+        return None
+    params = getattr(error, "params", None)
+    if not isinstance(params, Mapping):
+        return None
+    retryable = params.get("retryable")
+    if not isinstance(retryable, bool):
+        return None
+    user_message = error.args[0] if error.args else None
+    if not isinstance(user_message, str) or user_message == "":
+        return None
+    correlation_id = params.get("correlationId")
+    if not isinstance(correlation_id, str):
+        correlation_id = None
+    return LanguageModelCallError(
+        code=error.code,
+        user_message=user_message,
+        retryable=retryable,
+        correlation_id=correlation_id,
+        http_status=error.http_status,
+    )
+
+
+def _reraise_as_language_model_call_error(error: BaseException) -> NoReturn:
+    """Raise ``LanguageModelCallError`` for a contract error, else re-raise ``error``.
+
+    The SDK wraps the last error in ``APIError("Failed after N attempts")`` once
+    retries run out, so the contract is also read from ``error.__cause__``.
+    """
+    if isinstance(error, LanguageModelCallError):
+        raise error
+    for candidate in (error, error.__cause__):
+        if isinstance(candidate, unique_sdk.UniqueError):
+            converted = _language_model_call_error_from(candidate)
+            if converted is not None:
+                raise converted from error
+    raise error

{unique_toolkit-2026.44.0.dev9 → unique_toolkit-2026.44.1}/unique_toolkit/language_model/functions.py

@@ -16,6 +16,9 @@ from pydantic import BaseModel
 
 from unique_toolkit.chat.schemas import ChatMessage, ChatMessageRole
 from unique_toolkit.content.schemas import ContentChunk, ContentReference
+from unique_toolkit.language_model.errors import (
+    _reraise_as_language_model_call_error,
+)
 from unique_toolkit.language_model.infos import (
     LanguageModelInfo,
     LanguageModelName,
@@ -133,7 +136,7 @@ def complete(
         return LanguageModelResponse(**response)
     except Exception as e:
         logger.error(f"Error completing: {e}")
-        raise e
+        _reraise_as_language_model_call_error(e)
 
 
 async def complete_async(
@@ -173,8 +176,8 @@ async def complete_async(
 
     Raises:
     ------
-        Exception: If an error occurs during the request, an exception is raised
-        and logged.
+        LanguageModelCallError: The API returned the LLM error contract.
+        Exception: Any other request failure is logged and re-raised.
 
     """
     if not user_id:
@@ -217,7 +220,7 @@ async def complete_async(
         return LanguageModelResponse(**response)
     except Exception as e:
         logger.exception(f"Error completing: {e}")
-        raise e
+        _reraise_as_language_model_call_error(e)
 
 
 def _add_tools_to_options(