unique-toolkit 2026.38.0.dev8__tar.gz → 2026.38.0.dev10__tar.gz

{unique_toolkit-2026.38.0.dev8 → unique_toolkit-2026.38.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.38.0.dev8
+Version: 2026.38.0.dev10
 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>

{unique_toolkit-2026.38.0.dev8 → unique_toolkit-2026.38.0.dev10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.38.0.dev8"
+version = "2026.38.0.dev10"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

{unique_toolkit-2026.38.0.dev8 → unique_toolkit-2026.38.0.dev10}/unique_toolkit/chat/responses_api.py

@@ -161,8 +161,8 @@ def _prepare_responses_params_util(
 
     if other_options is not None:
         # Key word argument takes precedence
-        reasoning = reasoning or _attempt_extract_reasoning_from_options(other_options)
-        text = text or _attempt_extract_verbosity_from_options(other_options)
+        reasoning = reasoning or extract_reasoning_from_options(other_options)
+        text = text or extract_verbosity_from_options(other_options)
 
     if isinstance(model_name, LanguageModelName):
         model_info = LanguageModelInfo.from_name(model_name)
@@ -207,9 +207,15 @@ def _prepare_responses_params_util(
     log_exc_info=False,
     logger=logger,
 )
-def _attempt_extract_reasoning_from_options(
+def extract_reasoning_from_options(
     options: dict[str, Any],
 ) -> Reasoning | None:
+    """Build the Responses ``reasoning`` parameter from LLM options.
+
+    Accepts the Responses spelling (``reasoning``, dict or JSON string) as well
+    as the chat-completions spellings (``reasoning_effort`` / ``reasoningEffort``).
+    Returns ``None`` when no reasoning option is present or it fails validation.
+    """
     reasoning: dict[str, Any] | str | None = None
 
     # Responses API
@@ -243,9 +249,15 @@ def _attempt_extract_reasoning_from_options(
     log_exc_info=False,
     logger=logger,
 )
-def _attempt_extract_verbosity_from_options(
+def extract_verbosity_from_options(
     options: dict[str, Any],
 ) -> ResponseTextConfigParam | None:
+    """Build the Responses ``text`` parameter from LLM options.
+
+    Accepts the chat-completions spelling (flat ``verbosity``) as well as the
+    Responses spelling (``text``, dict or JSON string). Returns ``None`` when no
+    verbosity option is present or it fails validation.
+    """
     if "verbosity" in options:
         return TypeAdapter(ResponseTextConfigParam).validate_python(
             {"verbosity": options["verbosity"]}
@@ -270,6 +282,30 @@ def _attempt_extract_verbosity_from_options(
     return None
 
 
+# Keys translated into the Responses ``reasoning`` / ``text`` params; the flat
+# chat-completions spellings are rejected by /v1/responses if forwarded as-is.
+REASONING_OPTION_KEYS: tuple[str, ...] = (
+    "reasoning",
+    "reasoning_effort",
+    "reasoningEffort",
+)
+VERBOSITY_OPTION_KEYS: tuple[str, ...] = ("text", "verbosity")
+
+
+def strip_translated_responses_options(
+    other_options: dict[str, Any] | None,
+) -> dict[str, Any]:
+    """Return a copy of ``other_options`` without keys already mapped to
+    ``reasoning`` / ``text``."""
+    if not other_options:
+        return {}
+    return {
+        k: v
+        for k, v in other_options.items()
+        if k not in REASONING_OPTION_KEYS and k not in VERBOSITY_OPTION_KEYS
+    }
+
+
 def _prepare_responses_args(
     company_id: str,
     user_id: str,
@@ -330,9 +366,8 @@ def _prepare_responses_args(
     openai_options.update({k: v for k, v in explicit_options.items() if v is not None})  # pyright: ignore[reportArgumentType, reportCallIssue]
 
     # allow any other openai.resources.responses.Response.create options
-    if other_options is not None:
-        for k, v in other_options.items():
-            openai_options.setdefault(k, v)  # pyright: ignore[reportCallIssue, reportArgumentType]
+    for k, v in strip_translated_responses_options(other_options).items():
+        openai_options.setdefault(k, v)  # pyright: ignore[reportCallIssue, reportArgumentType]
 
     options["options"] = openai_options
 

{unique_toolkit-2026.38.0.dev8 → unique_toolkit-2026.38.0.dev10}/unique_toolkit/experimental/integrations/openai/streaming/event_routing/_model_params.py

@@ -8,14 +8,16 @@ from typing import Any
 
 from openai.types.shared_params import Reasoning
 
-from unique_toolkit.chat.responses_api import _attempt_extract_reasoning_from_options
+from unique_toolkit.chat.responses_api import (
+    extract_reasoning_from_options,
+    extract_verbosity_from_options,
+    strip_translated_responses_options,
+)
 from unique_toolkit.language_model.infos import LanguageModelInfo, LanguageModelName
 from unique_toolkit.language_model.schemas import reasoning_effort_to_openai
 
 _LOGGER = logging.getLogger(__name__)
 
-_REASONING_OPTION_KEYS = ("reasoning", "reasoning_effort", "reasoningEffort")
-
 
 def prepare_chat_completions_model_params(
     model_name: LanguageModelName | str,
@@ -61,8 +63,10 @@ def prepare_responses_model_params(
     Extracts reasoning from ``other_options`` when the explicit argument is
     missing (UniqueAI passes ``reasoning`` that way), applies
     ``LanguageModelInfo`` bounds, and bumps ``minimal`` effort to ``low`` when
-    a code-interpreter tool is present. Clamped temperature and resolved
-    reasoning are written onto the returned options dict.
+    a code-interpreter tool is present. Chat-completions ``reasoning_effort`` /
+    ``verbosity`` are mapped to ``reasoning`` / ``text`` and not forwarded
+    verbatim. Clamped temperature, reasoning and text are written onto the
+    returned options dict.
 
     Args:
         model_name (LanguageModelName | str): Model identifier from the caller.
@@ -74,11 +78,11 @@ def prepare_responses_model_params(
     Returns:
         dict[str, Any]: Sanitized create() options including ``temperature``.
     """
-    options = dict(other_options) if other_options else {}
+    raw_options = dict(other_options) if other_options else {}
     if reasoning is None:
-        reasoning = _attempt_extract_reasoning_from_options(options)
-    for key in _REASONING_OPTION_KEYS:
-        options.pop(key, None)
+        reasoning = extract_reasoning_from_options(raw_options)
+    text = extract_verbosity_from_options(raw_options)
+    options = strip_translated_responses_options(raw_options)
 
     requested_effort = reasoning.get("effort") if reasoning is not None else None
     temperature, resolved_effort = LanguageModelInfo.from_name(
@@ -91,6 +95,8 @@ def prepare_responses_model_params(
     options["temperature"] = temperature
     if reasoning is not None:
         options["reasoning"] = reasoning
+    if text is not None:
+        options["text"] = text
     return options
 
 

{unique_toolkit-2026.38.0.dev8 → unique_toolkit-2026.38.0.dev10}/unique_toolkit/language_model/model_costs.py

@@ -6,7 +6,7 @@ import time
 from pathlib import Path
 
 import yaml
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from unique_toolkit.language_model.schemas import LanguageModelTokenUsage
 
@@ -37,6 +37,50 @@ class ModelCost(BaseModel):
     cached_input: float | None = Field(default=None, alias="cachedInput")
     cache_write: float | None = Field(default=None, alias="cacheWrite")
     cache_write_1h: float | None = Field(default=None, alias="cacheWrite1h")
+    # Long-context tier: above the threshold the whole request (not just the
+    # overflow) is billed at these multipliers. All-or-none, see validator below.
+    long_context_threshold: int | None = Field(
+        default=None, alias="longContextThreshold"
+    )
+    long_context_input_multiplier: float | None = Field(
+        default=None, alias="longContextInputMultiplier"
+    )
+    long_context_completion_multiplier: float | None = Field(
+        default=None, alias="longContextCompletionMultiplier"
+    )
+
+    @model_validator(mode="after")
+    def _validate_long_context_all_or_none(self) -> "ModelCost":
+        fields = (
+            self.long_context_threshold,
+            self.long_context_input_multiplier,
+            self.long_context_completion_multiplier,
+        )
+        defined = [field for field in fields if field is not None]
+        if defined and len(defined) != len(fields):
+            raise ValueError(
+                "longContextThreshold, longContextInputMultiplier and "
+                "longContextCompletionMultiplier must be set together"
+            )
+        return self
+
+    def multipliers_for(self, prompt_tokens: int) -> tuple[float, float]:
+        """Return ``(input_multiplier, completion_multiplier)`` for a request.
+
+        ``prompt_tokens`` is the provider-reported input size of the single
+        request (for OpenAI this already includes cached tokens).
+        """
+        if (
+            self.long_context_threshold is None
+            or self.long_context_input_multiplier is None
+            or self.long_context_completion_multiplier is None
+            or prompt_tokens <= self.long_context_threshold
+        ):
+            return 1.0, 1.0
+        return (
+            self.long_context_input_multiplier,
+            self.long_context_completion_multiplier,
+        )
 
 
 class ModelCostCatalog(BaseModel):
@@ -119,7 +163,10 @@ def calculate_invocation_cost_usd(
     if model_cost is None:
         return None
 
+    input_multiplier, completion_multiplier = model_cost.multipliers_for(
+        token_usage.prompt_tokens
+    )
     return (
-        token_usage.prompt_tokens * model_cost.input
-        + token_usage.completion_tokens * model_cost.completion
+        token_usage.prompt_tokens * model_cost.input * input_multiplier
+        + token_usage.completion_tokens * model_cost.completion * completion_multiplier
     ) / _TOKENS_PER_MILLION