everalgo-user-memory 0.1.0__tar.gz

everalgo_user_memory-0.1.0/.gitignore

@@ -0,0 +1,58 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+*.egg
+wheels/
+
+# Environments
+.env
+.env.local
+.venv
+env/
+venv/
+
+# uv
+.uv/
+
+# Test / coverage / cache
+.pytest_cache/
+.cache
+.coverage
+.coverage.*
+coverage.xml
+report.xml
+htmlcov/
+.tox/
+.nox/
+.hypothesis/
+
+# Type checkers / linters
+.mypy_cache/
+.dmypy.json
+.pyre/
+.pytype/
+.ruff_cache/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# IDE / OS
+.vscode/
+.idea/
+*.swp
+.DS_Store
+
+# Logs
+*.log
+
+# Project local artifacts (placed under local/ per project convention)
+local/
+
+# Claude Code session-local state (scheduled tasks, agent caches, locks)
+.claude/

everalgo_user_memory-0.1.0/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+All notable changes to this package are documented here. Format follows
+[Keep a Changelog 1.1.0](https://keepachangelog.com/en/1.1.0/). Versioning
+follows [Semantic Versioning 2.0](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- `BoundaryDetector`: facade class wrapping `everalgo.boundary.detect_boundaries`; accepts `llm=` at construction time and manages the carry-forward `tail` across calls.
+- `EpisodeExtractor`: per-sender Episode fan-out — one LLM call per unique `sender_id` found in the `MemCell`; accepts `llm=` and `prompt=` at construction time.
+- `ForesightExtractor`: single `MemCell` → `list[Foresight]`; async with sync bridge via `asgiref.async_to_sync`.
+- `AtomicFactExtractor`: single `MemCell` → `list[AtomicFact]`; async with sync bridge.
+- `ProfileExtractor`: chronological `list[MemCell]` (last element = most recent) → single `Profile`; single-shot LLM snapshot.
+- English and Chinese prompts for all four extractors under `user_memory/prompts/{en,zh}/`.
+- `WorkspaceMemCellExtractor` re-export from `everalgo.boundary` for callers that import from one place.
+- `DetectionResult` re-export from `everalgo.boundary`.
+
+### Changed
+
+- `BoundaryDetector` renamed from `UserBoundaryDetector` (which was itself renamed from `ChatBoundaryDetector`) to match the no-prefix naming convention used across the package.
+- `EpisodeExtractor.aextract` parameter `owner_id` renamed to `sender_id` to align with `ChatMessage.sender_id`.
+- `ProfileExtractor` signature changed from separate `memcell` + `cluster_episodes` parameters to a single `memcells: Sequence[MemCell]` list, matching the other extractor contracts.
+- `Episode`, `Foresight`, `AtomicFact`, `Profile` schemas dropped `parent_id` / `parent_type` fields and the `id` field; schemas now carry only the minimal required fields plus `ConfigDict(extra="allow")`.
+
+[Unreleased]: https://github.com/EverMind-AI/EverAlgo/compare/main...HEAD

everalgo_user_memory-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EverMind
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

everalgo_user_memory-0.1.0/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: everalgo-user-memory
+Version: 0.1.0
+Summary: EverAlgo user memory: Episode / Foresight / AtomicFact / Profile extractors (re-exports boundary as Chat/WorkspaceMemCellExtractor).
+Project-URL: Homepage, https://github.com/EverMind-AI/EverAlgo
+Project-URL: Repository, https://github.com/EverMind-AI/EverAlgo
+Project-URL: Issues, https://github.com/EverMind-AI/EverAlgo/issues
+Project-URL: Documentation, https://github.com/EverMind-AI/EverAlgo/tree/main/packages/everalgo-user-memory
+Project-URL: Changelog, https://github.com/EverMind-AI/EverAlgo/blob/main/packages/everalgo-user-memory/CHANGELOG.md
+Author: EverMind
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: asgiref>=3.0
+Requires-Dist: everalgo-boundary<2.0.0,>=0.1.0
+Requires-Dist: everalgo-core<2.0.0,>=0.1.0
+Description-Content-Type: text/markdown
+
+# everalgo-user-memory
+
+User-side memory products for EverAlgo — four LLM-backed extractors (`EpisodeExtractor`, `ForesightExtractor`, `AtomicFactExtractor`, `ProfileExtractor`) plus a `BoundaryDetector` class facade that wraps `everalgo-boundary`.
+
+See the umbrella project: [EverAlgo monorepo](../../README.md) and the architecture document at [`docs/concepts/architecture.md`](../../docs/concepts/architecture.md).
+
+## Install
+
+```bash
+pip install everalgo-user-memory
+# Auto-pulls: everalgo-core, everalgo-boundary
+```
+
+## Quick start
+
+All extractors are stateless classes; pass `llm=` at construction time. The `sender_id` argument is always required and is not inferred from the conversation.
+
+```python
+import asyncio
+import json
+
+from everalgo.llm.types import ChatResponse
+from everalgo.testing.fake_llm import FakeLLMClient
+from everalgo.types import ChatMessage, MemCell
+from everalgo.user_memory import (
+    BoundaryDetector,
+    EpisodeExtractor,
+    ForesightExtractor,
+    AtomicFactExtractor,
+    ProfileExtractor,
+)
+
+_BOUNDARY_JSON = json.dumps({"reasoning": "single topic", "boundaries": [], "should_wait": False})
+_EPISODE_JSON  = json.dumps({"title": "Alice asks about async retries", "content": "Alice explored async retry patterns."})
+_FORE_JSON     = json.dumps([{"content": "Alice will read the follow-up doc", "evidence": "assistant promised a doc", "start_time": "2023-11-14", "end_time": "2023-11-21", "duration_days": 7}])
+_FACT_JSON     = json.dumps({"atomic_facts": {"time": "Nov 14 2023", "atomic_fact": ["Alice is learning Python async."]}})
+_PROFILE_JSON  = json.dumps({"explicit_info": [], "implicit_traits": [{"category": "Technical", "description": "Python developer."}]})
+
+
+async def main() -> None:
+    messages = [
+        ChatMessage(id="m1", role="user",      content="I want to learn Python async retry patterns.", timestamp=1_700_000_000_000, sender_id="u_alice", sender_name="Alice"),
+        ChatMessage(id="m2", role="assistant",  content="Sure — I'll send a follow-up doc next week.", timestamp=1_700_000_001_000, sender_id="assistant"),
+    ]
+
+    fake = FakeLLMClient(responses=[
+        ChatResponse(content=_BOUNDARY_JSON, model="fake"),
+        ChatResponse(content=_EPISODE_JSON,  model="fake"),
+        ChatResponse(content=_FORE_JSON,     model="fake"),
+        ChatResponse(content=_FACT_JSON,     model="fake"),
+        ChatResponse(content=_PROFILE_JSON,  model="fake"),
+    ])
+
+    # Step 1: boundary detection → MemCell
+    result = await BoundaryDetector(llm=fake).adetect(messages, is_final=True)
+    mc = result.cells[0]
+
+    # Step 2–4: user-memory extractors
+    episode   = await EpisodeExtractor(llm=fake).aextract(mc, sender_id="u_alice")
+    foresights = await ForesightExtractor(llm=fake).aextract(mc, sender_id="u_alice")
+    facts      = await AtomicFactExtractor(llm=fake).aextract(mc, sender_id="u_alice")
+
+    # Step 5: Profile takes a chronological Sequence[MemCell]; last is most recent
+    profile = await ProfileExtractor(llm=fake).aextract([mc], sender_id="u_alice")
+
+    print(episode.subject, profile.summary)
+
+
+asyncio.run(main())
+```
+
+See [`examples/06_full_user_memory_pipeline.py`](../../examples/06_full_user_memory_pipeline.py) for the complete end-to-end example including geometry clustering.
+
+## Customising prompts
+
+Each extractor accepts a `prompt=` override per call, or the module-level constant can be monkey-patched at startup for a global override:
+
+```python
+# Per-call: use the bundled Chinese variant
+from everalgo.user_memory.prompts.zh.episode import EPISODE_EXTRACT_PROMPT_ZH
+episode = await EpisodeExtractor(llm=client).aextract(mc, sender_id="u_alice", prompt=EPISODE_EXTRACT_PROMPT_ZH)
+
+# Global: replace the default English prompt at startup
+import everalgo.user_memory.prompts.en.foresight as _fs
+_fs.FORESIGHT_GENERATION_PROMPT = my_custom_prompt
+```
+
+## API surface
+
+```python
+class BoundaryDetector:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def adetect(
+        self, messages: list[ChatMessage], *, is_final: bool = False, prompt: str | None = None
+    ) -> DetectionResult: ...
+
+class EpisodeExtractor:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def aextract(
+        self, memcell: MemCell, *,
+        sender_id: str | None,           # None → generic whole-memcell episode (cheaper)
+        prompt: str | None = None,
+        custom_instructions: str | None = None,
+    ) -> Episode: ...
+
+class ForesightExtractor:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def aextract(
+        self, memcell: MemCell, *, sender_id: str, prompt: str | None = None
+    ) -> list[Foresight]: ...
+
+class AtomicFactExtractor:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def aextract(
+        self, memcell: MemCell, *,
+        sender_id: str | None,           # None → generic facts not bound to any user
+        prompt: str | None = None,
+    ) -> list[AtomicFact]: ...
+
+class ProfileExtractor:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def aextract(
+        self, memcells: Sequence[MemCell], *,
+        sender_id: str,
+        old_profile: Profile | None = None,   # None → INIT mode; present → UPDATE mode
+        prompt: str | None = None,
+    ) -> Profile: ...
+```
+
+`EpisodeExtractor` has two modes: pass `sender_id=str` to extract a user-focused episode (uses `USER_EPISODE_GENERATION_PROMPT`); pass `sender_id=None` for a generic whole-memcell episode (uses `EPISODE_GENERATION_PROMPT`).
+
+`ProfileExtractor` has two modes: `old_profile=None` triggers INIT extraction; passing an existing profile triggers UPDATE (LLM emits add/update/delete ops). When the merged profile exceeds an internal item count threshold a second compact LLM pass runs automatically — this is transparent to the caller.
+
+All class methods have a sync bridge: `extractor.extract(...)` is `async_to_sync(aextract)` — only for non-event-loop callers (CLI scripts, plain unit tests).
+
+## Testing
+
+```python
+from everalgo.testing import FakeLLMClient, assert_episode_shape
+
+fake = FakeLLMClient(responses=[ChatResponse(content=_EPISODE_JSON, model="fake")])
+episode = await EpisodeExtractor(llm=fake).aextract(mc, sender_id="u_alice")
+assert_episode_shape(episode)
+```
+
+See the integration test pattern in [`tests/integration/`](../../tests/integration/).
+
+## Related distributions
+
+- [`everalgo-boundary`](../everalgo-boundary/) — `detect_boundaries` primitive used by `BoundaryDetector`
+- [`everalgo-clustering`](../everalgo-clustering/) — geometry / LLM clustering for grouping MemCells before `ProfileExtractor`
+- [`everalgo-rank`](../everalgo-rank/) — ranks `Episode`, `AtomicFact`, `Profile` candidates at read time

everalgo_user_memory-0.1.0/README.md

@@ -0,0 +1,152 @@
+# everalgo-user-memory
+
+User-side memory products for EverAlgo — four LLM-backed extractors (`EpisodeExtractor`, `ForesightExtractor`, `AtomicFactExtractor`, `ProfileExtractor`) plus a `BoundaryDetector` class facade that wraps `everalgo-boundary`.
+
+See the umbrella project: [EverAlgo monorepo](../../README.md) and the architecture document at [`docs/concepts/architecture.md`](../../docs/concepts/architecture.md).
+
+## Install
+
+```bash
+pip install everalgo-user-memory
+# Auto-pulls: everalgo-core, everalgo-boundary
+```
+
+## Quick start
+
+All extractors are stateless classes; pass `llm=` at construction time. The `sender_id` argument is always required and is not inferred from the conversation.
+
+```python
+import asyncio
+import json
+
+from everalgo.llm.types import ChatResponse
+from everalgo.testing.fake_llm import FakeLLMClient
+from everalgo.types import ChatMessage, MemCell
+from everalgo.user_memory import (
+    BoundaryDetector,
+    EpisodeExtractor,
+    ForesightExtractor,
+    AtomicFactExtractor,
+    ProfileExtractor,
+)
+
+_BOUNDARY_JSON = json.dumps({"reasoning": "single topic", "boundaries": [], "should_wait": False})
+_EPISODE_JSON  = json.dumps({"title": "Alice asks about async retries", "content": "Alice explored async retry patterns."})
+_FORE_JSON     = json.dumps([{"content": "Alice will read the follow-up doc", "evidence": "assistant promised a doc", "start_time": "2023-11-14", "end_time": "2023-11-21", "duration_days": 7}])
+_FACT_JSON     = json.dumps({"atomic_facts": {"time": "Nov 14 2023", "atomic_fact": ["Alice is learning Python async."]}})
+_PROFILE_JSON  = json.dumps({"explicit_info": [], "implicit_traits": [{"category": "Technical", "description": "Python developer."}]})
+
+
+async def main() -> None:
+    messages = [
+        ChatMessage(id="m1", role="user",      content="I want to learn Python async retry patterns.", timestamp=1_700_000_000_000, sender_id="u_alice", sender_name="Alice"),
+        ChatMessage(id="m2", role="assistant",  content="Sure — I'll send a follow-up doc next week.", timestamp=1_700_000_001_000, sender_id="assistant"),
+    ]
+
+    fake = FakeLLMClient(responses=[
+        ChatResponse(content=_BOUNDARY_JSON, model="fake"),
+        ChatResponse(content=_EPISODE_JSON,  model="fake"),
+        ChatResponse(content=_FORE_JSON,     model="fake"),
+        ChatResponse(content=_FACT_JSON,     model="fake"),
+        ChatResponse(content=_PROFILE_JSON,  model="fake"),
+    ])
+
+    # Step 1: boundary detection → MemCell
+    result = await BoundaryDetector(llm=fake).adetect(messages, is_final=True)
+    mc = result.cells[0]
+
+    # Step 2–4: user-memory extractors
+    episode   = await EpisodeExtractor(llm=fake).aextract(mc, sender_id="u_alice")
+    foresights = await ForesightExtractor(llm=fake).aextract(mc, sender_id="u_alice")
+    facts      = await AtomicFactExtractor(llm=fake).aextract(mc, sender_id="u_alice")
+
+    # Step 5: Profile takes a chronological Sequence[MemCell]; last is most recent
+    profile = await ProfileExtractor(llm=fake).aextract([mc], sender_id="u_alice")
+
+    print(episode.subject, profile.summary)
+
+
+asyncio.run(main())
+```
+
+See [`examples/06_full_user_memory_pipeline.py`](../../examples/06_full_user_memory_pipeline.py) for the complete end-to-end example including geometry clustering.
+
+## Customising prompts
+
+Each extractor accepts a `prompt=` override per call, or the module-level constant can be monkey-patched at startup for a global override:
+
+```python
+# Per-call: use the bundled Chinese variant
+from everalgo.user_memory.prompts.zh.episode import EPISODE_EXTRACT_PROMPT_ZH
+episode = await EpisodeExtractor(llm=client).aextract(mc, sender_id="u_alice", prompt=EPISODE_EXTRACT_PROMPT_ZH)
+
+# Global: replace the default English prompt at startup
+import everalgo.user_memory.prompts.en.foresight as _fs
+_fs.FORESIGHT_GENERATION_PROMPT = my_custom_prompt
+```
+
+## API surface
+
+```python
+class BoundaryDetector:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def adetect(
+        self, messages: list[ChatMessage], *, is_final: bool = False, prompt: str | None = None
+    ) -> DetectionResult: ...
+
+class EpisodeExtractor:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def aextract(
+        self, memcell: MemCell, *,
+        sender_id: str | None,           # None → generic whole-memcell episode (cheaper)
+        prompt: str | None = None,
+        custom_instructions: str | None = None,
+    ) -> Episode: ...
+
+class ForesightExtractor:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def aextract(
+        self, memcell: MemCell, *, sender_id: str, prompt: str | None = None
+    ) -> list[Foresight]: ...
+
+class AtomicFactExtractor:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def aextract(
+        self, memcell: MemCell, *,
+        sender_id: str | None,           # None → generic facts not bound to any user
+        prompt: str | None = None,
+    ) -> list[AtomicFact]: ...
+
+class ProfileExtractor:
+    def __init__(self, *, llm: LLMClient) -> None: ...
+    async def aextract(
+        self, memcells: Sequence[MemCell], *,
+        sender_id: str,
+        old_profile: Profile | None = None,   # None → INIT mode; present → UPDATE mode
+        prompt: str | None = None,
+    ) -> Profile: ...
+```
+
+`EpisodeExtractor` has two modes: pass `sender_id=str` to extract a user-focused episode (uses `USER_EPISODE_GENERATION_PROMPT`); pass `sender_id=None` for a generic whole-memcell episode (uses `EPISODE_GENERATION_PROMPT`).
+
+`ProfileExtractor` has two modes: `old_profile=None` triggers INIT extraction; passing an existing profile triggers UPDATE (LLM emits add/update/delete ops). When the merged profile exceeds an internal item count threshold a second compact LLM pass runs automatically — this is transparent to the caller.
+
+All class methods have a sync bridge: `extractor.extract(...)` is `async_to_sync(aextract)` — only for non-event-loop callers (CLI scripts, plain unit tests).
+
+## Testing
+
+```python
+from everalgo.testing import FakeLLMClient, assert_episode_shape
+
+fake = FakeLLMClient(responses=[ChatResponse(content=_EPISODE_JSON, model="fake")])
+episode = await EpisodeExtractor(llm=fake).aextract(mc, sender_id="u_alice")
+assert_episode_shape(episode)
+```
+
+See the integration test pattern in [`tests/integration/`](../../tests/integration/).
+
+## Related distributions
+
+- [`everalgo-boundary`](../everalgo-boundary/) — `detect_boundaries` primitive used by `BoundaryDetector`
+- [`everalgo-clustering`](../everalgo-clustering/) — geometry / LLM clustering for grouping MemCells before `ProfileExtractor`
+- [`everalgo-rank`](../everalgo-rank/) — ranks `Episode`, `AtomicFact`, `Profile` candidates at read time

everalgo_user_memory-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "everalgo-user-memory"
+version = "0.1.0"
+description = "EverAlgo user memory: Episode / Foresight / AtomicFact / Profile extractors (re-exports boundary as Chat/WorkspaceMemCellExtractor)."
+requires-python = ">=3.12"
+license = "MIT"
+readme = "README.md"
+authors = [{ name = "EverMind" }]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+  "asgiref>=3.0",
+  "everalgo-boundary>=0.1.0,<2.0.0",
+  "everalgo-core>=0.1.0,<2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/EverMind-AI/EverAlgo"
+Repository = "https://github.com/EverMind-AI/EverAlgo"
+Issues = "https://github.com/EverMind-AI/EverAlgo/issues"
+Documentation = "https://github.com/EverMind-AI/EverAlgo/tree/main/packages/everalgo-user-memory"
+Changelog = "https://github.com/EverMind-AI/EverAlgo/blob/main/packages/everalgo-user-memory/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/everalgo"]

everalgo_user_memory-0.1.0/src/everalgo/user_memory/__init__.py

@@ -0,0 +1,28 @@
+"""User-side memory extractors — 4 Extractors + boundary facade + boundary re-exports.
+
+The user-scenario boundary facade (:class:`BoundaryDetector`) lives here; agent-trajectory
+boundary detection will be added to ``everalgo.agent_memory`` in Stage 4.
+"""
+
+import logging
+
+from everalgo.boundary import DetectionResult
+from everalgo.boundary.workspace import WorkspaceMemCellExtractor
+from everalgo.user_memory.atomic_fact import AtomicFactExtractor
+from everalgo.user_memory.boundary import BoundaryDetector
+from everalgo.user_memory.episode import EpisodeExtractor
+from everalgo.user_memory.foresight import ForesightExtractor
+from everalgo.user_memory.profile import ProfileExtractor
+
+__all__ = [
+    "AtomicFactExtractor",
+    "BoundaryDetector",
+    "DetectionResult",
+    "EpisodeExtractor",
+    "ForesightExtractor",
+    "ProfileExtractor",
+    "WorkspaceMemCellExtractor",
+]
+
+# Library logging setup (ADR-013): NullHandler on each subpackage logger.
+logging.getLogger(__name__).addHandler(logging.NullHandler())

everalgo_user_memory-0.1.0/src/everalgo/user_memory/_render.py

@@ -0,0 +1,28 @@
+"""Shared rendering helpers for user-memory extractors.
+
+This module is internal (``_render``-prefixed) — not part of the public API of ``everalgo.user_memory``.
+``render_content`` is re-exported from ``everalgo.types._render`` (moved to core in Stage 4 so that
+``everalgo-agent-memory`` can import it without creating a cross-package dependency on user-memory).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from everalgo.types._render import render_content
+from everalgo.types.chat import ChatMessage
+
+if TYPE_CHECKING:
+    from everalgo.types.conversation import MemCell
+
+__all__ = ["chat_messages", "render_content"]
+
+
+def chat_messages(memcell: MemCell) -> list[ChatMessage]:
+    """Filter ``memcell.items`` to ``ChatMessage`` entries only.
+
+    User-memory extractors silently skip ``ToolCallRequest`` / ``ToolCallResult`` — this is an
+    explicit contract supporting the agent → user-memory pipeline (see EverAlgo AGENTS.md). The
+    caller need not pre-filter; an AgentMemCell-shaped ``MemCell`` is acceptable input.
+    """
+    return [item for item in memcell.items if isinstance(item, ChatMessage)]