unique-toolkit 2026.36.0.dev6__tar.gz → 2026.36.0.dev7__tar.gz

{unique_toolkit-2026.36.0.dev6 → unique_toolkit-2026.36.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.36.0.dev6
+Version: 2026.36.0.dev7
 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.36.0.dev6 → unique_toolkit-2026.36.0.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.36.0.dev6"
+version = "2026.36.0.dev7"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

unique_toolkit-2026.36.0.dev7/unique_toolkit/experimental/integrations/openai/streaming/event_routing/_model_params.py

@@ -0,0 +1,133 @@
+"""Apply LanguageModelInfo constraints to experimental streaming requests."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Mapping, Sequence
+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.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,
+    temperature: float,
+    other_options: dict[str, Any] | None,
+) -> dict[str, Any]:
+    """Prepare Chat Completions create() options including clamped temperature.
+
+    Copies ``other_options`` so the caller dict is not mutated, applies
+    ``LanguageModelInfo`` temperature/reasoning rules, and writes the clamped
+    temperature onto the returned options dict.
+
+    Args:
+        model_name (LanguageModelName | str): Model identifier from the caller.
+        temperature (float): Requested sampling temperature.
+        other_options (dict[str, Any] | None): Extra OpenAI create() kwargs.
+
+    Returns:
+        dict[str, Any]: Sanitized create() options including ``temperature``.
+    """
+    options = dict(other_options) if other_options else {}
+    requested_effort = options.get("reasoning_effort")
+    temperature, resolved_effort = LanguageModelInfo.from_name(
+        model_name
+    ).resolve_temp_and_reasoning(temperature, requested_effort)
+    if resolved_effort is not None:
+        options["reasoning_effort"] = resolved_effort
+    else:
+        options.pop("reasoning_effort", None)
+    options["temperature"] = temperature
+    return options
+
+
+def prepare_responses_model_params(
+    model_name: LanguageModelName | str,
+    temperature: float,
+    reasoning: Reasoning | None,
+    other_options: dict[str, Any] | None,
+    tools: Sequence[Mapping[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Prepare Responses API create() options including clamped temperature.
+
+    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.
+
+    Args:
+        model_name (LanguageModelName | str): Model identifier from the caller.
+        temperature (float): Requested sampling temperature.
+        reasoning (Reasoning | None): Explicit Responses ``reasoning`` payload.
+        other_options (dict[str, Any] | None): Extra OpenAI create() kwargs.
+        tools (Sequence[Mapping[str, Any]] | None): Converted Responses tools.
+
+    Returns:
+        dict[str, Any]: Sanitized create() options including ``temperature``.
+    """
+    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)
+
+    requested_effort = reasoning.get("effort") if reasoning is not None else None
+    temperature, resolved_effort = LanguageModelInfo.from_name(
+        model_name
+    ).resolve_temp_and_reasoning(temperature, requested_effort)
+    reasoning = _bump_code_interpreter_effort(
+        _apply_resolved_reasoning(reasoning, resolved_effort),
+        tools,
+    )
+    options["temperature"] = temperature
+    if reasoning is not None:
+        options["reasoning"] = reasoning
+    return options
+
+
+def _apply_resolved_reasoning(
+    reasoning: Reasoning | None,
+    resolved_effort: str | None,
+) -> Reasoning | None:
+    """Write the resolved effort into a new Responses ``reasoning`` payload."""
+    if resolved_effort is not None:
+        reasoning = Reasoning(**(reasoning or {}))
+        reasoning["effort"] = reasoning_effort_to_openai(resolved_effort)
+        return reasoning
+    if reasoning is None or "effort" not in reasoning:
+        return reasoning
+    reasoning = Reasoning(**reasoning)
+    del reasoning["effort"]
+    if not reasoning:
+        return None
+    return reasoning
+
+
+def _bump_code_interpreter_effort(
+    reasoning: Reasoning | None,
+    tools: Sequence[Mapping[str, Any]] | None,
+) -> Reasoning | None:
+    """Code interpreter cannot run at ``minimal`` effort; bump to ``low``."""
+    if (
+        reasoning is None
+        or tools is None
+        or not any(tool["type"] == "code_interpreter" for tool in tools)
+        or reasoning.get("effort") != "minimal"
+    ):
+        return reasoning
+
+    _LOGGER.warning(
+        "Code interpreter cannot be used with `minimal` effort. Switching to `low`."
+    )
+    reasoning = Reasoning(**reasoning)
+    reasoning["effort"] = "low"
+    return reasoning

{unique_toolkit-2026.36.0.dev6 → unique_toolkit-2026.36.0.dev7}/unique_toolkit/experimental/integrations/openai/streaming/event_routing/chat_completions/complete_with_references.py

@@ -44,6 +44,7 @@ from unique_toolkit.language_model.schemas import (
 from unique_toolkit.protocols.support import SupportCompleteWithReferences
 
 from .._async_bridge import run_async_from_sync
+from .._model_params import prepare_chat_completions_model_params
 from ..events import (
     StreamEnded,
     StreamEventBus,
@@ -378,6 +379,10 @@ class ChatCompletionsCompleteWithReferences(SupportCompleteWithReferences):
         message_id = chat.last_assistant_message_id
         chat_id = chat.chat_id
 
+        other_options = prepare_chat_completions_model_params(
+            model_name, temperature, other_options
+        )
+
         gpt_messages = (
             messages.to_openai(mode="completions")
             if isinstance(messages, LanguageModelMessages)
@@ -389,9 +394,8 @@ class ChatCompletionsCompleteWithReferences(SupportCompleteWithReferences):
             optional_create_kwargs["tools"] = converted_tools
         if tool_choice is not None:
             optional_create_kwargs["tool_choice"] = tool_choice
-        if other_options:
-            for k, v in other_options.items():
-                optional_create_kwargs.setdefault(k, v)
+        for k, v in other_options.items():
+            optional_create_kwargs.setdefault(k, v)
 
         gpt_request: list[dict[str, Any]] = [
             dict(cast("Mapping[str, Any]", message)) for message in gpt_messages
@@ -444,7 +448,6 @@ class ChatCompletionsCompleteWithReferences(SupportCompleteWithReferences):
                     messages=gpt_messages,
                     stream=True,
                     stream_options=stream_options,
-                    temperature=temperature,
                     **optional_create_kwargs,
                 )
 

{unique_toolkit-2026.36.0.dev6 → unique_toolkit-2026.36.0.dev7}/unique_toolkit/experimental/integrations/openai/streaming/event_routing/responses/complete_with_references.py

@@ -39,6 +39,7 @@ from unique_toolkit.language_model.schemas import (
 from unique_toolkit.protocols.support import ResponsesSupportCompleteWithReferences
 
 from .._async_bridge import run_async_from_sync
+from .._model_params import prepare_responses_model_params
 from ..events import (
     ActivityProgress,
     StreamEnded,
@@ -512,8 +513,16 @@ class ResponsesCompleteWithReferences(ResponsesSupportCompleteWithReferences):
             )
 
         converted_messages = input_messages(messages)
-
         converted_tools = _convert_tools(tools)
+
+        other_options = prepare_responses_model_params(
+            model_name,
+            temperature,
+            reasoning,
+            other_options,
+            converted_tools,
+        )
+
         create_kwargs: dict[str, Any] = {}
         if converted_tools:
             create_kwargs["tools"] = converted_tools
@@ -533,16 +542,12 @@ class ResponsesCompleteWithReferences(ResponsesSupportCompleteWithReferences):
             create_kwargs["tool_choice"] = tool_choice
         if top_p is not None:
             create_kwargs["top_p"] = top_p
-        if reasoning is not None:
-            create_kwargs["reasoning"] = reasoning
-        if other_options:
-            for k, v in other_options.items():
-                create_kwargs.setdefault(k, v)
+        for k, v in other_options.items():
+            create_kwargs.setdefault(k, v)
         gpt_request: dict[str, Any] = {
             "model": model,
             "input": converted_messages,
             "stream": True,
-            "temperature": temperature,
             **create_kwargs,
         }
 
@@ -580,7 +585,6 @@ class ResponsesCompleteWithReferences(ResponsesSupportCompleteWithReferences):
                     model=model,
                     input=converted_messages,
                     stream=True,
-                    temperature=temperature,
                     **create_kwargs,
                 )
                 async with stream: