OpenAI o-series Unsupported Parameters (temperature, top_p, penalties)

from openai import OpenAI

client = OpenAI()


REASONING_MODELS = {"o3", "o3-mini", "o4-mini"}
GPT5_REASONING   = {"gpt-5.4", "gpt-5.5", "gpt-5.4-nano"}

# Parameters that reasoning models REJECT
UNSUPPORTED_ON_REASONING = {
    "temperature", "top_p", "presence_penalty", "frequency_penalty",
    "logit_bias", "logprobs", "top_logprobs", "n",
    "max_tokens",           # they want max_completion_tokens
}


def call(model: str, messages: list, **params) -> str:
    """Model-aware Chat Completions caller — strips unsupported params."""
    is_reasoning = model in REASONING_MODELS or model in GPT5_REASONING

    if is_reasoning:
        # Migrate max_tokens → max_completion_tokens
        if "max_tokens" in params:
            params["max_completion_tokens"] = params.pop("max_tokens")

        # Strip everything reasoning models reject
        stripped = {k: v for k, v in params.items() if k not in UNSUPPORTED_ON_REASONING}

        # Log what we removed for observability
        removed = set(params) - set(stripped) - {"max_completion_tokens"}
        if removed:
            import logging
            logging.info("stripped unsupported params for %s: %s", model, removed)

        params = stripped

    resp = client.chat.completions.create(
        model=model,
        messages=messages,
        **params,
    )
    return resp.choices[0].message.content


# ✅ Now this works for both model families
call("gpt-4.1", [{"role": "user", "content": "Hi"}], temperature=0.7, max_tokens=200)
call("o3",      [{"role": "user", "content": "Hi"}], temperature=0.7, max_tokens=200)
# ↑ temperature stripped, max_tokens migrated to max_completion_tokens


# ✅ Config-driven — YAML with per-model overrides
import yaml

CONFIG = yaml.safe_load("""
defaults:
  temperature: 0.5
  top_p: 0.9
  max_tokens: 500

models:
  gpt-4.1:
    temperature: 0.7
  o3:
    reasoning_effort: medium
    max_completion_tokens: 20000
    # No temperature — it's not supported

  gpt-5.4:
    reasoning:
      effort: minimal
    max_completion_tokens: 3000
""")


def call_from_config(model_name: str, prompt: str) -> str:
    # Start with defaults, apply model overrides
    params = {**CONFIG["defaults"], **CONFIG["models"].get(model_name, {})}
    return call(model_name, [{"role": "user", "content": prompt}], **params)


# ✅ For Responses API — parallel wrapper
def call_responses(model: str, input_text: str, **params):
    is_reasoning = model in REASONING_MODELS or model in GPT5_REASONING

    if is_reasoning:
        if "max_tokens" in params:
            params["max_output_tokens"] = params.pop("max_tokens")

        # Strip Chat Completions-style effort, migrate to nested
        if "reasoning_effort" in params:
            effort = params.pop("reasoning_effort")
            params["reasoning"] = {"effort": effort}

        stripped = {k: v for k, v in params.items() if k not in UNSUPPORTED_ON_REASONING}
        params = stripped

    return client.responses.create(model=model, input=input_text, **params)

from openai import OpenAI

client = OpenAI()


# ❌ OLD PATTERN — temperature controls creativity
resp = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Write a poem about databases"}],
    temperature=1.2,                        # creative
)


# ✅ NEW PATTERN — instruction controls creativity
resp = client.chat.completions.create(
    model="o3",
    messages=[{
        "role": "developer",
        "content": (
            "You are a creative poet. Take unusual metaphors and unexpected imagery. "
            "Avoid safe/generic phrasing. Prefer specific concrete words."
        ),
    }, {
        "role": "user",
        "content": "Write a poem about databases",
    }],
    max_completion_tokens=5000,
)


# ❌ OLD — n=3 for diverse variants
# resp = client.chat.completions.create(model="gpt-4.1", messages=[...], n=3, temperature=1.0)
# [c.message.content for c in resp.choices]


# ✅ NEW — three parallel calls with varied instructions
import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def variant(style: str, prompt: str):
    resp = await async_client.responses.create(
        model="o3",
        input=prompt,
        instructions=f"Respond in a {style} style.",
        max_output_tokens=2000,
    )
    return resp.output_text

async def get_variants(prompt: str):
    styles = ["formal and technical", "casual and playful", "concise and blunt"]
    return await asyncio.gather(*[variant(s, prompt) for s in styles])


# ❌ OLD — presence_penalty to avoid repetition
# resp = client.chat.completions.create(
#     model="gpt-4.1", messages=[...],
#     presence_penalty=1.5,                 # discourage repeats
# )


# ✅ NEW — instruct against repetition
resp = client.chat.completions.create(
    model="o3",
    messages=[{
        "role": "developer",
        "content": (
            "Avoid repeating information, phrases, or transition words across sentences. "
            "Each sentence should introduce a distinct idea."
        ),
    }, {
        "role": "user",
        "content": prompt,
    }],
    max_completion_tokens=8000,
)


# ❌ OLD — logprobs for confidence scoring
# resp = client.chat.completions.create(
#     model="gpt-4.1", messages=[...], logprobs=True, top_logprobs=5,
# )
# confidence = compute_confidence_from_logprobs(resp.choices[0].logprobs)


# ✅ NEW — ask for confidence in structured output
from pydantic import BaseModel, Field

class Classification(BaseModel):
    label: str
    confidence: float = Field(ge=0.0, le=1.0, description="Self-reported confidence 0-1")
    reasoning: str

resp = client.responses.parse(
    model="o3",
    input=text_to_classify,
    text_format=Classification,
    max_output_tokens=15000,
    reasoning={"effort": "medium"},
)
result: Classification = resp.output_parsed
print(f"{result.label} (confidence: {result.confidence:.2f})")


# ✅ For deterministic output (temperature=0 replacement)
# Reasoning models are already fairly deterministic. Add:
#   - Explicit output format specification
#   - Rule: "If uncertain, output exactly 'UNKNOWN'"
#   - Structured output schema
# Then use seed if available (some models support it):
resp = client.responses.create(
    model="o3",
    input=prompt,
    max_output_tokens=5000,
    # seed=42,                              # verify seed support on your model
)

from openai import OpenAI

client = OpenAI()


# ✅ CURRENT o-series — system role is accepted (treated as developer)
resp = client.chat.completions.create(
    model="o3",
    messages=[
        {"role": "system", "content": "You are a concise SQL expert."},
        {"role": "user",   "content": "Write a query for last month's top customers."},
    ],
    max_completion_tokens=15_000,
)


# ✅ Also works with explicit developer role
resp = client.chat.completions.create(
    model="o3",
    messages=[
        {"role": "developer", "content": "You are a concise SQL expert."},
        {"role": "user",      "content": "Write a query..."},
    ],
    max_completion_tokens=15_000,
)


# ✅ Responses API — instructions field is cleanest
resp = client.responses.create(
    model="o3",
    instructions="You are a concise SQL expert.",
    input="Write a query for last month's top customers.",
    max_output_tokens=15_000,
    reasoning={"effort": "medium"},
)


# ❌ ANTI-PATTERN — legacy defensive code that strips system on o-series
# This was needed for o1 (which rejected system) but now removes needed instructions.
def bad_strip(messages, model):
    if model.startswith("o"):
        return [m for m in messages if m["role"] != "system"]
    return messages


# ✅ NEW — leave system messages in place; they work
def messages_for_model(messages, model):
    if model.startswith("o1"):
        # o1 specifically still rejects system messages (verify per-model)
        return [{"role": "developer" if m["role"] == "system" else m["role"], "content": m["content"]} for m in messages]
    # o3, o4-mini, GPT-5 all accept system role
    return messages


# ✅ Don't use both a system and a developer message
# Some models are strict about only one high-priority instruction message.
# Pick one:
messages = [
    {"role": "system", "content": "You are a Sudoku solver."},
    # DO NOT ALSO include: {"role": "developer", "content": "..."}
    {"role": "user", "content": "Solve: ..."},
]