OpenAI o-series reasoning_effort Parameter Support & Errors

from openai import OpenAI

client = OpenAI()


# ✅ CHAT COMPLETIONS — flat reasoning_effort
resp_cc = client.chat.completions.create(
    model="o3",
    messages=[{"role": "user", "content": "Refactor this function..."}],
    reasoning_effort="medium",              # flat string
    max_completion_tokens=20_000,
)


# ✅ RESPONSES API — nested reasoning object
resp_r = client.responses.create(
    model="o3",
    input="Refactor this function...",
    reasoning={"effort": "medium"},         # nested dict
    max_output_tokens=20_000,
)


# ✅ RESPONSES API — with summary opt-in
resp_r2 = client.responses.create(
    model="o3",
    input="Explain this stack trace...",
    reasoning={
        "effort": "high",
        "summary": "auto",                  # request reasoning summary in output
    },
    max_output_tokens=60_000,
)


# ✅ Cross-API helper — one function, both surfaces
def with_effort(api: str, model: str, prompt: str, effort: str, budget: int):
    if api == "chat_completions":
        return client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": prompt}],
            reasoning_effort=effort,
            max_completion_tokens=budget,
        )
    elif api == "responses":
        return client.responses.create(
            model=model,
            input=prompt,
            reasoning={"effort": effort, "summary": "auto"},
            max_output_tokens=budget,
        )
    raise ValueError(f"unknown api: {api}")


# ❌ WRONG — nested shape on Chat Completions
# resp = client.chat.completions.create(
#     model="o3",
#     messages=[...],
#     reasoning={"effort": "medium"},       # 400: unknown parameter
# )


# ❌ WRONG — flat shape on Responses (silently accepted as unknown top-level, ignored)
# resp = client.responses.create(
#     model="o3",
#     input="...",
#     reasoning_effort="medium",            # rejected as unknown parameter
# )

from openai import OpenAI
from dataclasses import dataclass

client = OpenAI()


@dataclass
class ReasoningProfile:
    model: str
    effort: str | None
    budget: int
    max_latency_s: float
    typical_cost_ratio: float    # relative to non-reasoning baseline


PROFILES = {
    "fast_classify":  ReasoningProfile("gpt-5.4-nano", "minimal", 2_000,   1.0,  1.2),
    "quick_answer":   ReasoningProfile("gpt-5.4",      "low",     5_000,   3.0,  2.0),
    "code_review":    ReasoningProfile("o3",           "medium",  20_000, 10.0,  8.0),
    "deep_debug":     ReasoningProfile("o3",           "high",    60_000, 45.0, 25.0),
    "no_reasoning":   ReasoningProfile("gpt-5.4",      "none",    3_000,   2.0,  1.0),
}


def call(profile_name: str, prompt: str) -> str:
    p = PROFILES[profile_name]

    kwargs = {
        "model": p.model,
        "input": prompt,
        "max_output_tokens": p.budget,
    }
    if p.effort:
        kwargs["reasoning"] = {"effort": p.effort}

    resp = client.responses.create(**kwargs)
    return resp.output_text


# Use it
short = call("quick_answer", "What is OAuth PKCE in one paragraph?")
review = call("code_review", f"Review for concurrency bugs:\n{code}")
debug = call("deep_debug", f"Why does this test hang?\n{trace}")


# ✅ Latency-tiered — pick effort under a hard latency budget
def call_within_latency(prompt: str, max_seconds: float) -> str:
    profile_by_latency = [
        (1.0, "fast_classify"),
        (3.0, "quick_answer"),
        (10.0, "code_review"),
        (45.0, "deep_debug"),
    ]
    for max_s, name in profile_by_latency:
        if max_s <= max_seconds:
            chosen = name
    return call(chosen, prompt)


# ✅ Cost-tiered — hard cap on relative cost vs baseline
def call_within_cost(prompt: str, max_cost_ratio: float) -> str:
    ordered = sorted(PROFILES.items(), key=lambda kv: kv[1].typical_cost_ratio, reverse=True)
    chosen = None
    for name, p in ordered:
        if p.typical_cost_ratio <= max_cost_ratio:
            chosen = name
            break
    if chosen is None:
        chosen = "no_reasoning"
    return call(chosen, prompt)


# ✅ Escalation pattern — start low, retry higher if quality insufficient
def call_with_escalation(prompt: str, quality_check) -> str:
    for profile_name in ["quick_answer", "code_review", "deep_debug"]:
        answer = call(profile_name, prompt)
        if quality_check(answer):
            return answer
    return answer   # best effort

from openai import OpenAI
import warnings

client = OpenAI()


REASONING_EFFORT_SUPPORTED = {
    "o3":            {"low", "medium", "high"},
    "o3-mini":       {"low", "medium", "high"},
    # o4-mini deliberately absent — parameter is a no-op
    "gpt-5.4":       {"minimal", "low", "medium", "high", "none"},
    "gpt-5.5":       {"minimal", "low", "medium", "high", "none"},
    "gpt-5.4-nano":  {"minimal", "low", "medium", "high", "none"},
}


def call_with_effort_check(model: str, prompt: str, effort: str, budget: int):
    """Warn if effort will be ignored; call anyway."""
    supported = REASONING_EFFORT_SUPPORTED.get(model)
    if supported is None:
        warnings.warn(
            f"Model {model!r} does not support reasoning_effort — parameter will be ignored. "
            f"Use one of {list(REASONING_EFFORT_SUPPORTED.keys())} for effort control.",
            UserWarning, stacklevel=2,
        )
        # Fall back to a call without the param
        return client.responses.create(
            model=model,
            input=prompt,
            max_output_tokens=budget,
        )

    if effort not in supported:
        raise ValueError(
            f"Model {model!r} accepts {sorted(supported)}, got {effort!r}"
        )

    return client.responses.create(
        model=model,
        input=prompt,
        reasoning={"effort": effort},
        max_output_tokens=budget,
    )


# ✅ Router — pick the right model for the requested effort
def pick_model_for_effort(effort: str) -> str:
    if effort == "minimal" or effort == "none":
        return "gpt-5.4"                    # only GPT-5 accepts these
    if effort in {"low", "medium", "high"}:
        return "o3"                         # o3 for full control
    raise ValueError(f"unknown effort: {effort}")


# ✅ Batch classifier — cheap, no reasoning
resp = client.responses.create(
    model="gpt-5.4",
    input=user_input,
    reasoning={"effort": "none"},           # behaves as non-reasoning
    max_output_tokens=200,
)


# ✅ Use o4-mini for its fixed-budget sweet spot, not for control
# o4-mini is best when you WANT the default reasoning depth without tuning.
resp = client.chat.completions.create(
    model="o4-mini",
    messages=[{"role": "user", "content": prompt}],
    max_completion_tokens=15_000,
    # Do NOT bother passing reasoning_effort — it's ignored.
)