Skip to content

CompactionStarted

autogen.beta.events.lifecycle.CompactionStarted #

CompactionStarted(*args, **kwargs)

Bases: BaseEvent

Emitted on the agent's stream when compaction begins.

Paired with either CompactionCompleted (success) or CompactionFailed (the strategy raised). Subscribe to both if you need to know that a compaction attempt was made — relying on CompactionCompleted alone hides errors.

Source code in autogen/beta/events/base.py 
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
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)

agent instance-attribute #

agent

strategy instance-attribute #

strategy

event_count instance-attribute #

event_count

created_at class-attribute instance-attribute #

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

to_dict #

to_dict()

Serialize this event to a JSON-compatible dictionary.

Source code in autogen/beta/events/base.py 
225
226
227
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 
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
@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 in getattr(klass, "_event_fields_", {}):
            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)