Skip to content

OpenAIResponsesLLMConfigEntry

autogen.oai.client.OpenAIResponsesLLMConfigEntry #

Bases: OpenAILLMConfigEntry

LLMConfig entry for the OpenAI Responses API (stateful, tool-enabled).

This reuses all the OpenAI fields but changes api_type so the wrapper can route traffic to the client.responses endpoint instead of chat.completions. It inherits everything else – including reasoning fields – from OpenAILLMConfigEntry so users can simply set

{
    "api_type": "responses",  # <-- key differentiator
    "model": "o3",  # reasoning model
    "reasoning_effort": "medium",  # low / medium / high
    "stream": True,
}

api_type class-attribute instance-attribute #

api_type = 'responses'

tool_choice class-attribute instance-attribute #

tool_choice = 'auto'

built_in_tools class-attribute instance-attribute #

built_in_tools = None

max_tokens class-attribute instance-attribute #

max_tokens = Field(default=None, ge=0)

top_p class-attribute instance-attribute #

top_p = Field(default=None, gt=0, lt=1)

temperature class-attribute instance-attribute #

temperature = Field(default=None, ge=0, le=1)

model class-attribute instance-attribute #

model = Field(..., min_length=1)

api_key class-attribute instance-attribute #

api_key = None

api_version class-attribute instance-attribute #

api_version = None

base_url class-attribute instance-attribute #

base_url = None

voice class-attribute instance-attribute #

voice = None

model_client_cls class-attribute instance-attribute #

model_client_cls = None

http_client class-attribute instance-attribute #

http_client = None

response_format class-attribute instance-attribute #

response_format = None

default_headers class-attribute instance-attribute #

default_headers = None

tags class-attribute instance-attribute #

tags = Field(default_factory=list)

model_config class-attribute instance-attribute #

model_config = ConfigDict(extra='allow', arbitrary_types_allowed=True)

price class-attribute instance-attribute #

price = Field(default=None, min_length=2, max_length=2)

user class-attribute instance-attribute #

user = None

stream class-attribute instance-attribute #

stream = False

verbosity class-attribute instance-attribute #

verbosity = None

extra_body class-attribute instance-attribute #

extra_body = None

reasoning_effort class-attribute instance-attribute #

reasoning_effort = None

max_completion_tokens class-attribute instance-attribute #

max_completion_tokens = None

create_client #

create_client()
Source code in autogen/oai/client.py 
1487
1488
def create_client(self) -> ModelClient:  # pragma: no cover
    raise NotImplementedError("Handled via OpenAIWrapper._register_default_client")

apply_application_config #

apply_application_config(application_config)

Apply application level configurations.

Source code in autogen/llm_config/entry.py 
58
59
60
61
62
63
64
def apply_application_config(self, application_config: ApplicationConfig) -> "LLMConfigEntry":
    """Apply application level configurations."""
    # TODO: should create a new instance instead of mutating current one
    self.max_tokens = self.max_tokens or application_config.max_tokens
    self.top_p = self.top_p or application_config.top_p
    self.temperature = self.temperature or application_config.temperature
    return self

check_base_url classmethod #

check_base_url(v, info)
Source code in autogen/llm_config/entry.py 
69
70
71
72
73
74
75
76
@field_validator("base_url", mode="before")
@classmethod
def check_base_url(cls, v: HttpUrl | str | None, info: ValidationInfo) -> str | None:
    if v is None:  # Handle None case explicitly
        return None
    if not str(v).startswith("https://") and not str(v).startswith("http://"):
        return f"http://{str(v)}"
    return str(v)

serialize_base_url #

serialize_base_url(v)
Source code in autogen/llm_config/entry.py 
78
79
80
@field_serializer("base_url", when_used="unless-none")  # Ensure serializer also respects None
def serialize_base_url(self, v: HttpUrl | None) -> str | None:
    return str(v) if v is not None else None

serialize_api_key #

serialize_api_key(v)
Source code in autogen/llm_config/entry.py 
82
83
84
@field_serializer("api_key", when_used="unless-none")
def serialize_api_key(self, v: SecretStr) -> str:
    return v.get_secret_value()

model_dump #

model_dump(*args, exclude_none=True, **kwargs)
Source code in autogen/llm_config/entry.py 
86
87
def model_dump(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> dict[str, Any]:
    return BaseModel.model_dump(self, exclude_none=exclude_none, *args, **kwargs)

model_dump_json #

model_dump_json(*args, exclude_none=True, **kwargs)
Source code in autogen/llm_config/entry.py 
89
90
def model_dump_json(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> str:
    return BaseModel.model_dump_json(self, exclude_none=exclude_none, *args, **kwargs)

get #

get(key, default=None)
Source code in autogen/llm_config/entry.py 
92
93
94
95
96
def get(self, key: str, default: Any | None = None) -> Any:
    val = getattr(self, key, default)
    if isinstance(val, SecretStr):
        return val.get_secret_value()
    return val

items #

items()
Source code in autogen/llm_config/entry.py 
113
114
115
def items(self) -> Iterable[tuple[str, Any]]:
    d = self.model_dump()
    return d.items()

keys #

keys()
Source code in autogen/llm_config/entry.py 
117
118
119
def keys(self) -> Iterable[str]:
    d = self.model_dump()
    return d.keys()

values #

values()
Source code in autogen/llm_config/entry.py 
121
122
123
def values(self) -> Iterable[Any]:
    d = self.model_dump()
    return d.values()