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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.38.0.dev8
+Version: 2026.38.0.dev9
 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.dev9}/pyproject.toml

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

{unique_toolkit-2026.38.0.dev8 → unique_toolkit-2026.38.0.dev9}/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.dev9}/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