Skip to content

ModelResponse

autogen.beta.events.types.ModelResponse #

ModelResponse(*args, **kwargs)

Bases: ModelEvent

Final model response produced for a given request.

Source code in autogen/beta/events/base.py 
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
def __init__(self, *args: Any, **kwargs: Any) -> None:
    # MRO walk: map positional args and collect defaults.
    positional_names: list[str] = []
    defaults: dict[str, Any] = {}
    seen: set[str] = set()

    for klass in reversed(type(self).__mro__):
        for name, f in getattr(klass, "_event_fields_", {}).items():
            if name not in seen:
                if not f.kw_only:
                    positional_names.append(name)
                if name not in kwargs:
                    default = f.get_default()
                    if default is not Ellipsis:
                        defaults[name] = default
            seen.add(name)

    if args:
        if len(args) > len(positional_names):
            raise TypeError(
                f"{type(self).__name__}() takes {len(positional_names)} "
                f"positional argument(s) but {len(args)} were given"
            )
        for name, value in zip(positional_names, args):
            if name in kwargs:
                raise TypeError(f"{type(self).__name__}() got multiple values for argument '{name}'")
            kwargs[name] = value
            defaults.pop(name, None)

    # Apply defaults first, then user-provided kwargs so that
    # property setters (e.g. content -> _content) aren't overwritten
    # by a field default applied afterwards.
    for key, value in defaults.items():
        setattr(self, key, value)
    for key, value in kwargs.items():
        setattr(self, key, value)

message class-attribute instance-attribute #

message = Field(default=None, kw_only=False)

tool_calls class-attribute instance-attribute #

tool_calls = Field(default_factory=ToolCallsEvent)

usage class-attribute instance-attribute #

usage = Field(default_factory=Usage)

response_force class-attribute instance-attribute #

response_force = False

files class-attribute instance-attribute #

files = Field(default_factory=list)

model class-attribute instance-attribute #

model = Field(default=None, compare=False)

provider class-attribute instance-attribute #

provider = Field(default=None, compare=False)

finish_reason class-attribute instance-attribute #

finish_reason = Field(default=None, compare=False)

metadata property #

metadata

content property #

content

created_at class-attribute instance-attribute #

created_at = Field(default_factory=time, compare=False, repr=False)

to_api #

to_api()
Source code in autogen/beta/events/types.py 
116
117
118
119
120
121
122
123
def to_api(self) -> dict[str, Any]:
    msg = {
        "content": self.message.content if self.message else None,
        "role": "assistant",
    }
    if self.tool_calls:
        msg["tool_calls"] = self.tool_calls.to_api()
    return msg

to_dict #

to_dict()

Serialize this event to a JSON-compatible dictionary.

Source code in autogen/beta/events/base.py 
204
205
206
def to_dict(self) -> dict[str, Any]:
    """Serialize this event to a JSON-compatible dictionary."""
    return event_to_dict(self)

from_dict classmethod #

from_dict(data)

Reconstruct an event from a serialized dictionary.

Filters input to only fields known by this class (via MRO Field descriptors), then constructs via cls(**filtered).

Source code in autogen/beta/events/base.py 
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
@classmethod
def from_dict(cls, data: dict[str, Any]) -> "BaseEvent":
    """Reconstruct an event from a serialized dictionary.

    Filters input to only fields known by this class (via MRO Field
    descriptors), then constructs via ``cls(**filtered)``.
    """
    # Collect known field names across the MRO
    known_fields: set[str] = set()
    for klass in cls.__mro__:
        for name, f in getattr(klass, "_event_fields_", {}).items():
            known_fields.add(name)

    # Deserialize nested events/special types, then filter to known fields
    deserialized = deserialize_payload(data)
    filtered = {k: v for k, v in deserialized.items() if k in known_fields}
    return cls(**filtered)