pi-ai-python 1.3.0__py3-none-any.whl

pi_ai/api/openai_decisions.py

@@ -0,0 +1,210 @@
+"""OpenAI's Decisions API: ``POST /v1/decisions`` with ``{model, input, questions}``.
+
+https://developers.openai.com/api/docs/guides/decisions
+
+The state is sent as JSON text. With images, the input becomes one user message
+with the state as ``input_text`` followed by ``input_image`` data URLs. Questions
+map to Decisions types: ``choice`` to ``choice``, ``score`` to ``score``, and
+``bool`` to ``predicate``. Predicates have no criteria field, so the meanings of
+true and false are appended to the instructions.
+
+Only OpenAI API keys work: Sign in with ChatGPT tokens are rejected on this route.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any
+from urllib.parse import urljoin
+
+from ..types import (
+    ClassifierAnswer,
+    ClassifierBoolAnswer,
+    ClassifierBoolQuestion,
+    ClassifierChoiceAnswer,
+    ClassifierContext,
+    ClassifierModel,
+    ClassifierQuestion,
+    ClassifierResult,
+    ClassifierScoreAnswer,
+    now_ms,
+)
+from ..utils.error_body import format_provider_error, normalize_provider_error
+from ..utils.model_operations import classifier_error_result
+from .classifier_shared import (
+    classifier_questions,
+    is_record,
+    parse_classifier_usage,
+    post_classifier_request,
+    required_number,
+)
+
+__all__ = ["classify"]
+
+LABEL = "OpenAI Decisions"
+
+#: The endpoint accepts at most this many image parts per request.
+MAX_IMAGES = 128
+
+#: Cloudflare in front of api.openai.com answers 504 with an HTML page when a request runs
+#: longer than about five seconds. Large inputs, currently above roughly 600K tokens, hit
+#: this limit, and retrying the same input runs into it again, so 504 is not retried.
+NO_RETRY_STATUSES = (504,)
+
+
+def _predicate_instructions(question: ClassifierBoolQuestion) -> str:
+    meanings = [
+        f"True means: {question.criteria['true']}" if question.criteria.get("true") else "",
+        f"False means: {question.criteria['false']}" if question.criteria.get("false") else "",
+    ]
+    meanings = [meaning for meaning in meanings if meaning]
+    return question.instructions + "\n\n" + "\n".join(meanings) if meanings else question.instructions
+
+
+def _wire_question(name: str, question: ClassifierQuestion) -> dict[str, Any]:
+    if question.type == "choice":
+        return {
+            "type": "choice",
+            "name": name,
+            "instructions": question.instructions,
+            "choices": [
+                {"value": value, "description": description} if description else {"value": value}
+                for value, description in question.criteria.items()
+            ],
+        }
+    if question.type == "score":
+        return {
+            "type": "score",
+            "name": name,
+            "instructions": question.instructions,
+            "levels": [{"label": label} for label in question.criteria],
+        }
+    return {"type": "predicate", "name": name, "instructions": _predicate_instructions(question)}
+
+
+def _wire_input(context: ClassifierContext) -> Any:
+    state = json.dumps(context.state, ensure_ascii=False, separators=(",", ":"))
+    images = context.images or []
+    if not images:
+        return state
+    if len(images) > MAX_IMAGES:
+        raise ValueError(f"{LABEL} accepts at most {MAX_IMAGES} images, got {len(images)}")
+    return [
+        {
+            "role": "user",
+            "content": [
+                {"type": "input_text", "text": state},
+                *(
+                    {"type": "input_image", "image_url": f"data:{image.mime_type};base64,{image.data}"}
+                    for image in images
+                ),
+            ],
+        }
+    ]
+
+
+def _choice_probabilities(value: Any, question_id: str) -> dict[str, float]:
+    if not isinstance(value, list):
+        raise ValueError(f"{LABEL} returned invalid probabilities for {question_id}")
+    probabilities: dict[str, float] = {}
+    for entry in value:
+        if not is_record(entry) or not isinstance(entry.get("value"), str):
+            raise ValueError(f"{LABEL} returned invalid probabilities for {question_id}")
+        choice = entry["value"]
+        probabilities[choice] = required_number(
+            LABEL, entry.get("probability"), f"probability for {question_id}.{choice}"
+        )
+    return probabilities
+
+
+def _parse_answer(question_id: str, question: ClassifierQuestion, answer: Mapping[str, Any]) -> ClassifierAnswer:
+    kind = answer.get("type")
+    if kind == "refusal":
+        raise ValueError(f"{LABEL} refused to answer {question_id}")
+    if question.type == "choice":
+        choice = answer.get("choice")
+        if kind != "choice" or not isinstance(choice, str):
+            raise ValueError(f"{LABEL} did not return a choice answer for {question_id}")
+        return ClassifierChoiceAnswer(
+            choice=choice,
+            probabilities=_choice_probabilities(answer.get("probabilities"), question_id),
+            confidence=required_number(LABEL, answer.get("confidence"), f"confidence for {question_id}"),
+        )
+    if question.type == "score":
+        if kind != "score":
+            raise ValueError(f"{LABEL} did not return a score answer for {question_id}")
+        return ClassifierScoreAnswer(
+            score=required_number(LABEL, answer.get("score"), f"score for {question_id}"),
+            confidence=required_number(LABEL, answer.get("confidence"), f"confidence for {question_id}"),
+        )
+    if kind != "predicate":
+        raise ValueError(f"{LABEL} did not return a predicate answer for {question_id}")
+    return ClassifierBoolAnswer(
+        probability=required_number(LABEL, answer.get("probability"), f"probability for {question_id}")
+    )
+
+
+def _parse_answers(value: Any, questions: Mapping[str, ClassifierQuestion]) -> dict[str, ClassifierAnswer]:
+    if not isinstance(value, list):
+        raise ValueError(f"{LABEL} returned an unexpected response")
+    by_name: dict[str, Mapping[str, Any]] = {}
+    for answer in value:
+        if is_record(answer) and isinstance(answer.get("name"), str):
+            by_name[answer["name"]] = answer
+    answers: dict[str, ClassifierAnswer] = {}
+    for question_id, question in questions.items():
+        answer = by_name.get(question_id)
+        if answer is None:
+            raise ValueError(f"{LABEL} did not return an answer for {question_id}")
+        answers[question_id] = _parse_answer(question_id, question, answer)
+    return answers
+
+
+def _error_message(error: Exception) -> str:
+    if getattr(error, "status", None) == 504:
+        return (
+            f"{LABEL} error (504): the request timed out at the gateway. Very large inputs "
+            "(above roughly 600K tokens) currently exceed its time limit."
+        )
+    return format_provider_error(normalize_provider_error(error), f"{LABEL} error")
+
+
+async def classify(
+    model: ClassifierModel, context: ClassifierContext, options: Mapping[str, Any] | None = None
+) -> ClassifierResult:
+    """Classification through OpenAI's Decisions API. Never raises."""
+    options = options or {}
+    output = ClassifierResult(
+        api=model.api, provider=model.provider, model=model.id, answers={}, stop_reason="stop", timestamp=now_ms()
+    )
+    try:
+        if model.api != "openai-decisions":
+            raise ValueError(f"Unsupported classifier API: {model.api}")
+        questions = classifier_questions(context)
+        body = await post_classifier_request(
+            LABEL,
+            urljoin(f"{model.base_url.rstrip('/')}/", "decisions"),
+            model,
+            {
+                "model": model.id,
+                "input": _wire_input(context),
+                "questions": [_wire_question(name, question) for name, question in questions.items()],
+            },
+            options,
+            NO_RETRY_STATUSES,
+        )
+        if not is_record(body):
+            raise ValueError(f"{LABEL} returned an unexpected response")
+        # Set before parsing answers: a request with malformed or refused answers was still billed.
+        usage = parse_classifier_usage(body.get("usage"), model)
+        if usage is not None:
+            output.usage = usage
+        output.answers = _parse_answers(body.get("answers"), questions)
+        return output
+    except Exception as error:
+        signal = options.get("signal")
+        failed = classifier_error_result(model, _error_message(error), aborted=signal is not None and signal.aborted)
+        failed.usage = output.usage
+        failed.timestamp = output.timestamp
+        return failed

pi_ai/api/openai_prompt_cache.py

@@ -0,0 +1,19 @@
+"""OpenAI prompt-cache key helpers."""
+
+from __future__ import annotations
+
+__all__ = ["OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH", "clamp_openai_prompt_cache_key"]
+
+OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64
+
+
+def clamp_openai_prompt_cache_key(key: str | None) -> str | None:
+    """Truncate a prompt cache key to OpenAI's limit, counting code points.
+
+    JavaScript's ``Array.from`` counts code points too, so keys match the TypeScript port.
+    """
+    if key is None:
+        return None
+    if len(key) <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH:
+        return key
+    return key[:OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH]

pi_ai/api/openai_responses.py

@@ -0,0 +1,418 @@
+# pyright: reportAttributeAccessIssue=false, reportArgumentType=false
+# Converters branch on ``role``/``type`` discriminators held in locals, which pyright does not narrow.
+"""OpenAI Responses API (``openai-responses``).
+
+Streams ``responses.create`` through the official ``openai`` SDK (``AsyncOpenAI``).
+Also used by OpenAI-compatible Responses endpoints (xAI, GitHub Copilot, OpenRouter,
+OpenCode, Cloudflare AI Gateway, ...).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal
+
+from ..abort import abort_scope
+from ..event_stream import AssistantMessageEventStream
+from ..models import clamp_thinking_level
+from ..types import (
+    AssistantMessage,
+    DoneEvent,
+    ErrorEvent,
+    Model,
+    ProviderResponse,
+    StartEvent,
+    StreamOptions,
+    TranscriptContext,
+    Usage,
+)
+from ..utils.callbacks import maybe_await
+from ..utils.error_body import format_provider_error, normalize_provider_error
+from ..utils.misc import get_pi_user_agent, get_provider_env_value, headers_to_record
+from ..utils.transcript import get_declared_tools, resolve_transcript, resolve_transcript_tools
+from .constrained_sampling import create_grammar_tool_input_properties
+from .github_copilot_headers import build_copilot_dynamic_headers, has_copilot_vision_input
+from .openai_prompt_cache import clamp_openai_prompt_cache_key
+from .openai_responses_shared import convert_responses_messages, convert_responses_tools, process_responses_stream
+from .openai_sdk import (
+    create_openai_client,
+    iter_sdk_stream,
+    merge_sdk_headers,
+    open_sdk_stream,
+    openai_request,
+    sdk_body_arguments,
+)
+from .simple_options import build_base_options, resolve_sampling_params
+
+__all__ = [
+    "OpenAIResponsesOptions",
+    "OPENAI_TOOL_CALL_PROVIDERS",
+    "stream",
+    "stream_simple",
+]
+
+OPENAI_TOOL_CALL_PROVIDERS = frozenset({"openai", "openai-codex", "opencode"})
+# OpenAI Responses rejects max_output_tokens below 16: https://github.com/earendil-works/pi/issues/6265
+OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16
+CHATGPT_USAGE_URL = "https://chatgpt.com/settings/usage"
+# Fixed reasoning.effort while configuration_update items carry the thinking level.
+CONFIGURATION_UPDATE_REQUEST_EFFORT = "medium"
+
+
+class OpenAIResponsesOptions(StreamOptions, total=False):
+    reasoning_effort: Literal["minimal", "low", "medium", "high", "xhigh", "max"]
+    reasoning_summary: Literal["auto", "detailed", "concise"] | None
+    service_tier: str
+    tool_choice: Any
+
+
+def _is_chatgpt_sign_in(model: Model, api_key: str | None) -> bool:
+    """OpenAI API keys start with ``sk-``; another credential sent directly to OpenAI is a
+    Sign in with ChatGPT access token."""
+    return (
+        model.provider == "openai"
+        and model.base_url == "https://api.openai.com/v1"
+        and api_key is not None
+        and not api_key.startswith("sk-")
+    )
+
+
+def _has_header(headers: Mapping[str, str | None] | None, name: str) -> bool:
+    if not headers:
+        return False
+    expected = name.lower()
+    return any(key.lower() == expected and value is not None and value.strip() != "" for key, value in headers.items())
+
+
+def _get_client_api_key(provider: str, api_key: str | None, headers: Mapping[str, str | None] | None) -> str:
+    if api_key:
+        return api_key
+    if _has_header(headers, "authorization") or _has_header(headers, "cf-aig-authorization"):
+        return "unused"
+    raise RuntimeError(f"No API key for provider: {provider}")
+
+
+def _detect_session_affinity_format(model: Model) -> str:
+    return "openrouter" if model.provider == "openrouter" or "openrouter.ai" in model.base_url else "openai"
+
+
+def _resolve_cache_retention(cache_retention: str | None, env: Mapping[str, str] | None) -> str:
+    """Default ``"short"``; ``PI_CACHE_RETENTION=long`` is honored for backward compatibility."""
+    if cache_retention:
+        return cache_retention
+    if get_provider_env_value("PI_CACHE_RETENTION", env) == "long":
+        return "long"
+    return "short"
+
+
+def _compat_value(compat: Mapping[str, Any], key: str, default: Any) -> Any:
+    value = compat.get(key)
+    return default if value is None else value
+
+
+def _get_compat(model: Model) -> dict[str, Any]:
+    compat = model.compat or {}
+    return {
+        "supportsDeveloperRole": _compat_value(compat, "supportsDeveloperRole", True),
+        "supportsMidConvoSystemMessages": _compat_value(compat, "supportsMidConvoSystemMessages", False),
+        "sessionAffinityFormat": _compat_value(compat, "sessionAffinityFormat", None)
+        or _detect_session_affinity_format(model),
+        "supportsLongCacheRetention": _compat_value(compat, "supportsLongCacheRetention", True),
+        "supportsStrictMode": _compat_value(compat, "supportsStrictMode", False),
+        "supportsOpenAIGrammarTools": _compat_value(compat, "supportsOpenAIGrammarTools", False),
+        "supportsAdditionalTools": _compat_value(compat, "supportsAdditionalTools", False),
+        "supportsToolSearch": _compat_value(compat, "supportsToolSearch", False),
+        "supportsExplicitPromptCacheMode": _compat_value(compat, "supportsExplicitPromptCacheMode", False),
+        "supportsMaxOutputTokens": _compat_value(compat, "supportsMaxOutputTokens", True),
+        "supportsMidConvoEffort": _compat_value(compat, "supportsMidConvoEffort", False),
+    }
+
+
+def _map_thinking_level(model: Model, level: str) -> str:
+    level_map = model.thinking_level_map or {}
+    mapped = level_map.get(level)
+    return mapped if mapped is not None else level
+
+
+def _get_configuration_update_effort(model: Model, options: Mapping[str, Any], compat: Mapping[str, Any]) -> str | None:
+    """Effort to send in ``configuration_update`` items, or ``None`` to send it as ``reasoning.effort``."""
+    reasoning_effort = options.get("reasoning_effort")
+    if (
+        not compat["supportsMidConvoEffort"]
+        or not reasoning_effort
+        # Sign in with ChatGPT rejects configuration_update items.
+        or _is_chatgpt_sign_in(model, options.get("api_key"))
+    ):
+        return None
+    return _map_thinking_level(model, reasoning_effort)
+
+
+def _get_prompt_cache_retention(compat: Mapping[str, Any], cache_retention: str) -> str | None:
+    if (
+        cache_retention == "long"
+        and compat["supportsLongCacheRetention"]
+        and not compat["supportsExplicitPromptCacheMode"]
+    ):
+        return "24h"
+    return None
+
+
+def _get_prompt_cache_options(compat: Mapping[str, Any], cache_retention: str) -> dict[str, Any] | None:
+    if not compat["supportsExplicitPromptCacheMode"]:
+        return None
+    if cache_retention == "none":
+        return {"mode": "explicit"}
+    if cache_retention == "long" and compat["supportsLongCacheRetention"]:
+        return {"ttl": "30m"}
+    return None
+
+
+def stream(
+    model: Model, context: TranscriptContext, options: Mapping[str, Any] | None = None
+) -> AssistantMessageEventStream:
+    """Stream a response from the OpenAI Responses API."""
+    opts: dict[str, Any] = dict(options or {})
+    out = AssistantMessageEventStream()
+    normalized_context = resolve_transcript(context, _get_compat(model)["supportsMidConvoSystemMessages"])
+    out.start(_run(model, normalized_context, opts, out))
+    return out
+
+
+async def _run(
+    model: Model, context: TranscriptContext, options: dict[str, Any], out: AssistantMessageEventStream
+) -> None:
+    compat = _get_compat(model)
+    configuration_update_effort = _get_configuration_update_effort(model, options, compat)
+    output = AssistantMessage(
+        [],
+        api=model.api,
+        provider=model.provider,
+        model=model.id,
+        usage=Usage(),
+        stop_reason="pending",
+        provider_thinking_level=configuration_update_effort,
+    )
+    signal = options.get("signal")
+    try:
+        async with abort_scope(signal):
+            api_key = _get_client_api_key(model.provider, options.get("api_key"), options.get("headers"))
+            cache_retention = _resolve_cache_retention(options.get("cache_retention"), options.get("env"))
+            cache_session_id = None if cache_retention == "none" else options.get("session_id")
+            grammar_tool_input_properties = create_grammar_tool_input_properties(
+                get_declared_tools(context.messages), compat["supportsOpenAIGrammarTools"]
+            )
+            headers = _build_request_headers(model, context, options, compat, cache_session_id)
+            client = create_openai_client(api_key=api_key, base_url=model.base_url, headers=headers, options=options)
+            params: Any = _build_params(
+                model, context, options, compat, grammar_tool_input_properties, configuration_update_effort
+            )
+            on_payload = options.get("on_payload")
+            if on_payload is not None:
+                next_params = await maybe_await(on_payload(params, model))
+                if next_params is not None:
+                    params = next_params
+            create = client.responses.with_raw_response.create
+            body_arguments = sdk_body_arguments(params, headers=headers)
+            raw = await openai_request(lambda: create(stream=True, **body_arguments), options)
+            sdk_stream = open_sdk_stream(raw)
+            try:
+                on_response = options.get("on_response")
+                if on_response is not None:
+                    await maybe_await(
+                        on_response(ProviderResponse(raw.status_code, headers_to_record(raw.headers)), model)
+                    )
+                out.push(StartEvent(output))
+                await process_responses_stream(
+                    iter_sdk_stream(sdk_stream),
+                    output,
+                    out,
+                    model,
+                    {
+                        "on_provider_stream_event": options.get("on_provider_stream_event"),
+                        "service_tier": options.get("service_tier"),
+                        "grammar_tool_input_properties": grammar_tool_input_properties,
+                        "apply_service_tier_pricing": lambda usage, tier: _apply_service_tier_pricing(
+                            usage, tier, model
+                        ),
+                    },
+                )
+            finally:
+                await sdk_stream.close()
+
+        if signal is not None and signal.aborted:
+            raise RuntimeError("Request was aborted")
+        if output.stop_reason == "pending":
+            raise RuntimeError("OpenAI Responses stream ended without a stop reason")
+        if output.stop_reason in ("aborted", "error"):
+            raise RuntimeError(output.error_message or "An unknown error occurred")
+
+        out.push(DoneEvent(output.stop_reason, output))  # type: ignore[arg-type]
+        out.end()
+    except Exception as error:
+        aborted = signal is not None and signal.aborted
+        output.stop_reason = "aborted" if aborted else "error"
+        if aborted:
+            error_message = "Request was aborted"
+        else:
+            prefix = "OpenAI" if model.provider == "openai" else model.provider
+            error_message = format_provider_error(normalize_provider_error(error), f"{prefix} API error")
+        # Sign in with ChatGPT shares the subscription's usage limit with other apps.
+        output.error_message = (
+            f"{error_message}\nCheck your ChatGPT usage: {CHATGPT_USAGE_URL}"
+            if "subscription_sharing_usage_limit_exceeded" in error_message
+            else error_message
+        )
+        out.push(ErrorEvent(output.stop_reason, output))  # type: ignore[arg-type]
+        out.end()
+
+
+def stream_simple(
+    model: Model, context: TranscriptContext, options: Mapping[str, Any] | None = None
+) -> AssistantMessageEventStream:
+    """Stream with provider-neutral options (``reasoning``, ``tool_choice``, ...)."""
+    options = options or {}
+    _get_client_api_key(model.provider, options.get("api_key"), options.get("headers"))
+
+    base = build_base_options(model, context, options, options.get("api_key"))
+    if options.get("tool_choice") is not None:
+        base["tool_choice"] = options["tool_choice"]
+    reasoning = options.get("reasoning")
+    clamped = clamp_thinking_level(model, reasoning) if reasoning else None
+    if clamped is not None and clamped != "off":
+        base["reasoning_effort"] = clamped
+    return stream(model, context, base)
+
+
+def _build_request_headers(
+    model: Model,
+    context: TranscriptContext,
+    options: Mapping[str, Any],
+    compat: Mapping[str, Any],
+    session_id: str | None,
+) -> dict[str, str | None]:
+    """The client's ``default_headers``: ``None`` removes a header, SDK defaults included."""
+    copilot_headers: dict[str, str] | None = None
+    if model.provider == "github-copilot":
+        copilot_headers = build_copilot_dynamic_headers(
+            messages=context.messages, has_images=has_copilot_vision_input(context.messages)
+        )
+
+    session_headers: dict[str, str] = {}
+    if session_id:
+        affinity_format = compat["sessionAffinityFormat"]
+        if affinity_format == "openrouter":
+            session_headers["x-session-id"] = session_id
+        else:
+            if affinity_format == "openai":
+                session_headers["session_id"] = session_id
+            session_headers["x-client-request-id"] = session_id
+
+    return merge_sdk_headers(
+        {"User-Agent": get_pi_user_agent()},
+        model.headers,
+        copilot_headers,
+        session_headers,
+        # Options headers last so they can override defaults.
+        options.get("headers"),
+    )
+
+
+def _build_params(
+    model: Model,
+    context: TranscriptContext,
+    options: Mapping[str, Any],
+    compat: Mapping[str, Any],
+    grammar_tool_input_properties: Mapping[str, str],
+    configuration_update_effort: str | None,
+) -> dict[str, Any]:
+    transcript_tools = resolve_transcript_tools(
+        context.messages, compat["supportsAdditionalTools"] or compat["supportsToolSearch"]
+    )
+    tool_options = {
+        "supports_strict_mode": compat["supportsStrictMode"],
+        "supports_openai_grammar_tools": compat["supportsOpenAIGrammarTools"],
+    }
+    messages_options: dict[str, Any] = {
+        "grammar_tool_input_properties": grammar_tool_input_properties,
+        "supports_mid_convo_system_messages": compat["supportsMidConvoSystemMessages"],
+        "supports_additional_tools": compat["supportsAdditionalTools"],
+        "supports_tool_search": compat["supportsToolSearch"],
+        "tool_options": tool_options,
+    }
+    if configuration_update_effort is not None:
+        messages_options["configuration_update_effort"] = configuration_update_effort
+    messages = convert_responses_messages(model, context, OPENAI_TOOL_CALL_PROVIDERS, messages_options)  # type: ignore[arg-type]
+
+    cache_retention = _resolve_cache_retention(options.get("cache_retention"), options.get("env"))
+    # Sign in with ChatGPT rejects these request fields.
+    omit_unsupported_fields = _is_chatgpt_sign_in(model, options.get("api_key"))
+    params: dict[str, Any] = {"model": model.id, "input": messages, "stream": True}
+    prompt_cache_key = None if cache_retention == "none" else clamp_openai_prompt_cache_key(options.get("session_id"))
+    if prompt_cache_key is not None:
+        params["prompt_cache_key"] = prompt_cache_key
+    if not omit_unsupported_fields:
+        retention = _get_prompt_cache_retention(compat, cache_retention)
+        if retention is not None:
+            params["prompt_cache_retention"] = retention
+        cache_options = _get_prompt_cache_options(compat, cache_retention)
+        if cache_options is not None:
+            params["prompt_cache_options"] = cache_options
+    params["store"] = False
+
+    max_tokens = options.get("max_tokens")
+    if max_tokens and compat["supportsMaxOutputTokens"] and not omit_unsupported_fields:
+        params["max_output_tokens"] = max(max_tokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS)
+
+    if options.get("temperature") is not None and not omit_unsupported_fields:
+        params["temperature"] = options["temperature"]
+
+    if options.get("service_tier") is not None:
+        params["service_tier"] = options["service_tier"]
+
+    if transcript_tools.request_tools:
+        params["tools"] = convert_responses_tools(transcript_tools.request_tools, tool_options)  # type: ignore[arg-type]
+
+    if options.get("tool_choice") is not None:
+        params["tool_choice"] = options["tool_choice"]
+
+    requested = options.get("reasoning_effort")
+    reasoning_effort = requested or ("medium" if options.get("reasoning_summary") else None)
+    if model.reasoning:
+        level_map = model.thinking_level_map or {}
+        if reasoning_effort:
+            requested_effort = _map_thinking_level(model, requested) if requested else reasoning_effort
+            effort = requested_effort if configuration_update_effort is None else CONFIGURATION_UPDATE_REQUEST_EFFORT
+            params["reasoning"] = {"effort": effort, "summary": options.get("reasoning_summary") or "auto"}
+            params["include"] = ["reasoning.encrypted_content"]
+        elif model.provider != "github-copilot" and not ("off" in level_map and level_map["off"] is None):
+            off = level_map.get("off")
+            params["reasoning"] = {"effort": off if off is not None else "none"}
+        if model.provider == "xai":
+            params["include"] = ["reasoning.encrypted_content"]
+
+    # Last so model and request sampling parameters override named request fields.
+    sampling_params = resolve_sampling_params(model, reasoning_effort or "off", options.get("sampling_params"))
+    if sampling_params:
+        params.update(sampling_params)
+
+    return params
+
+
+def _get_service_tier_cost_multiplier(model: Model, service_tier: Any) -> float:
+    if service_tier == "flex":
+        return 0.5
+    if service_tier in ("priority", "fast"):
+        return 2.5 if model.id == "gpt-5.5" else 2
+    return 1
+
+
+def _apply_service_tier_pricing(usage: Usage, service_tier: Any, model: Model) -> None:
+    multiplier = _get_service_tier_cost_multiplier(model, service_tier)
+    if multiplier == 1:
+        return
+    cost = usage.cost
+    cost.input *= multiplier
+    cost.output *= multiplier
+    cost.cache_read *= multiplier
+    cost.cache_write *= multiplier
+    cost.total = cost.input + cost.output + cost.cache_read + cost.cache_write