pipecat-memorysync 1.0.0__tar.gz → 1.1.0__tar.gz

pipecat_memorysync-1.1.0/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+All notable changes to `pipecat-memorysync` are documented here.
+
+## 1.1.0 — 2026-08-29
+
+- **Turn-complete capture.** Voice aggregators split one utterance across
+  several context messages at speech pauses; those fragments previously
+  stored as separate rows ("and", "dinner", …). Consecutive new user
+  fragments now merge into ONE verbatim turn, stored when the assistant
+  reply completes the turn; an in-progress utterance is flushed as one
+  merged turn at end of call. Assistant turns still store immediately,
+  and a failed store releases its fragments for retry on the next frame.
+- Delta-only and idempotency guarantees unchanged; suite grows to 17
+  checks on Pipecat v1.8.1 (fragment merging, end-of-call tail flush,
+  failed-store retry).
+
+## 1.0.1 — 2026-08-29
+
+- Metadata only: the source repository moved to
+  `https://github.com/memorysyncio/memorysync-pipecat`; project URLs updated.
+  No code changes.
+
+## 1.0.0 — 2026-08-29
+
+Initial release.
+
+- `MemorySyncMemoryService`, a `FrameProcessor` for the position between the
+  user context aggregator and the LLM service.
+- Budgeted memory recall (default 1.2 s hard timeout) injected into every
+  `LLMContextFrame` as a guarded system message — a slow or unreachable
+  backend degrades to an unenriched frame, never a stalled reply.
+- Delta-only capture with deterministic idempotency seeds: only turns not
+  seen before are persisted, with role fidelity for user and assistant.
+- Injection exclusion: the injected memory block is never re-captured.
+- Graceful `EndFrame` flush (bounded 3 s window) and `CancelFrame` salvage.
+- Tested with Pipecat v1.8.1 through `pipecat.tests.utils.run_test`
+  (14-test suite).

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.1.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.5
 Name: pipecat-memorysync
-Version: 1.0.0
+Version: 1.1.0
 Summary: MemorySync for Pipecat: budgeted memory recall that never stalls a voice reply, delta-only conversation persistence with idempotency seeds, and a pipeline that cannot be broken by a memory outage.
 Project-URL: Homepage, https://docs.memorysync.io/guides/pipecat
 Project-URL: Documentation, https://docs.memorysync.io/guides/pipecat
-Project-URL: Repository, https://github.com/Rafay121/memorysync-plugins
+Project-URL: Repository, https://github.com/memorysyncio/memorysync-pipecat
+Project-URL: Changelog, https://github.com/memorysyncio/memorysync-pipecat/blob/main/CHANGELOG.md
 Author-email: MemorySync <support@memorysync.io>
 License-Expression: MIT
 Keywords: agents,long-term-memory,memory,memorysync,pipecat,voice
@@ -21,14 +22,22 @@ Requires-Dist: httpx<1,>=0.25
 Requires-Dist: pipecat-ai<2,>=1.0.0
 Description-Content-Type: text/markdown
 
-# pipecat-memorysync
+# memorysync-pipecat
 
 [MemorySync](https://memorysync.io) for [Pipecat](https://github.com/pipecat-ai/pipecat) —
 long-term memory for voice pipelines that never stalls a reply and never
-re-stores what it already knows.
+re-stores what it already knows. PyPI package: **`pipecat-memorysync`**.
+
+Built and maintained by the [MemorySync](https://memorysync.io) team —
+MemorySync is our product, and this integration is actively maintained
+alongside it.
+
+**Tested with Pipecat v1.8.1** (`pipecat-ai>=1.0.0,<2`).
 
 ```bash
 pip install pipecat-memorysync
+# or
+uv add pipecat-memorysync
 ```
 
 ## Where it sits
@@ -72,10 +81,13 @@ enriched or not, on time.
 - **Budgeted recall.** Enrichment runs under a hard timeout (default
   **1.2 s**). A slow or dead memory backend means an unenriched frame, never a
   stalled voice reply.
+- **Turn-complete capture.** Voice aggregators split one utterance across
+  several context messages at speech pauses; consecutive fragments merge
+  into ONE stored turn when the assistant's reply completes it (the
+  in-progress tail flushes at end of call) — no per-fragment junk rows.
 - **Delta-only capture.** Only messages *not seen before* are stored, tracked
   by deterministic idempotency seeds. Growing a 50-message context does not
-  re-store 50 messages per turn (a real flaw in some in-tree memory services,
-  which re-send the entire context every frame — O(n²) writes per call).
+  re-store 50 messages per turn.
 - **Injection exclusion.** The memory block this service adds is never captured
   back as a new memory.
 - **Graceful end, salvaged abort.** On `EndFrame`, queued writes get a bounded
@@ -85,6 +97,25 @@ enriched or not, on time.
 - **Failure-proof.** HTTP errors, quota limits, and timeouts all degrade to
   "no memories this turn". Nothing propagates into the pipeline.
 
+## Running the example
+
+A single-file voice agent that remembers callers across calls lives in
+[`examples/foundational.py`](examples/foundational.py):
+
+```bash
+uv add pipecat-memorysync "pipecat-ai[deepgram,cartesia,openai,silero,runner,webrtc]"
+
+export MEMORYSYNC_API_KEY=ms_...   # https://app.memorysync.io
+export DEEPGRAM_API_KEY=...
+export CARTESIA_API_KEY=...
+export OPENAI_API_KEY=...
+
+python examples/foundational.py
+```
+
+Open `http://localhost:7860/client`, tell the bot your name and a preference,
+hang up, and connect again — it remembers.
+
 ## Configuration (`InputParams`)
 
 ```python
@@ -128,6 +159,10 @@ python -m venv venv && venv/Scripts/pip install -e . pipecat-ai pytest pytest-as
 venv/Scripts/python -m pytest tests -q    # 14 tests, run via pipecat's official test harness
 ```
 
+## Docs
+
+Full guide: [docs.memorysync.io/guides/pipecat](https://docs.memorysync.io/guides/pipecat)
+
 ## License
 
 MIT

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.1.0}/README.md

@@ -1,11 +1,19 @@
-# pipecat-memorysync
+# memorysync-pipecat
 
 [MemorySync](https://memorysync.io) for [Pipecat](https://github.com/pipecat-ai/pipecat) —
 long-term memory for voice pipelines that never stalls a reply and never
-re-stores what it already knows.
+re-stores what it already knows. PyPI package: **`pipecat-memorysync`**.
+
+Built and maintained by the [MemorySync](https://memorysync.io) team —
+MemorySync is our product, and this integration is actively maintained
+alongside it.
+
+**Tested with Pipecat v1.8.1** (`pipecat-ai>=1.0.0,<2`).
 
 ```bash
 pip install pipecat-memorysync
+# or
+uv add pipecat-memorysync
 ```
 
 ## Where it sits
@@ -49,10 +57,13 @@ enriched or not, on time.
 - **Budgeted recall.** Enrichment runs under a hard timeout (default
   **1.2 s**). A slow or dead memory backend means an unenriched frame, never a
   stalled voice reply.
+- **Turn-complete capture.** Voice aggregators split one utterance across
+  several context messages at speech pauses; consecutive fragments merge
+  into ONE stored turn when the assistant's reply completes it (the
+  in-progress tail flushes at end of call) — no per-fragment junk rows.
 - **Delta-only capture.** Only messages *not seen before* are stored, tracked
   by deterministic idempotency seeds. Growing a 50-message context does not
-  re-store 50 messages per turn (a real flaw in some in-tree memory services,
-  which re-send the entire context every frame — O(n²) writes per call).
+  re-store 50 messages per turn.
 - **Injection exclusion.** The memory block this service adds is never captured
   back as a new memory.
 - **Graceful end, salvaged abort.** On `EndFrame`, queued writes get a bounded
@@ -62,6 +73,25 @@ enriched or not, on time.
 - **Failure-proof.** HTTP errors, quota limits, and timeouts all degrade to
   "no memories this turn". Nothing propagates into the pipeline.
 
+## Running the example
+
+A single-file voice agent that remembers callers across calls lives in
+[`examples/foundational.py`](examples/foundational.py):
+
+```bash
+uv add pipecat-memorysync "pipecat-ai[deepgram,cartesia,openai,silero,runner,webrtc]"
+
+export MEMORYSYNC_API_KEY=ms_...   # https://app.memorysync.io
+export DEEPGRAM_API_KEY=...
+export CARTESIA_API_KEY=...
+export OPENAI_API_KEY=...
+
+python examples/foundational.py
+```
+
+Open `http://localhost:7860/client`, tell the bot your name and a preference,
+hang up, and connect again — it remembers.
+
 ## Configuration (`InputParams`)
 
 ```python
@@ -105,6 +135,10 @@ python -m venv venv && venv/Scripts/pip install -e . pipecat-ai pytest pytest-as
 venv/Scripts/python -m pytest tests -q    # 14 tests, run via pipecat's official test harness
 ```
 
+## Docs
+
+Full guide: [docs.memorysync.io/guides/pipecat](https://docs.memorysync.io/guides/pipecat)
+
 ## License
 
 MIT

pipecat_memorysync-1.1.0/examples/foundational.py

@@ -0,0 +1,128 @@
+#
+# Foundational example: a voice agent that remembers callers across calls.
+#
+# MemorySyncMemoryService sits between the user context aggregator and the
+# LLM: every LLMContextFrame is enriched with relevant long-term memories
+# under a hard time budget, and new turns are persisted in the background.
+# A slow or unreachable memory backend can never stall the voice reply.
+#
+# Run (choose any transport supported by the Pipecat runner):
+#
+#   uv add pipecat-memorysync "pipecat-ai[deepgram,cartesia,openai,silero,runner,webrtc]"
+#   export MEMORYSYNC_API_KEY=ms_...   # https://app.memorysync.io
+#   export DEEPGRAM_API_KEY=...
+#   export CARTESIA_API_KEY=...
+#   export OPENAI_API_KEY=...
+#   python foundational.py
+#
+# Then open http://localhost:7860/client, talk to the bot, tell it your
+# name and a preference, hang up, and call again: it remembers.
+#
+
+import os
+
+from dotenv import load_dotenv
+from loguru import logger
+
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.frames.frames import LLMRunFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.processors.aggregators.llm_response_universal import (
+    LLMContextAggregatorPair,
+    LLMUserAggregatorParams,
+)
+from pipecat.runner.types import RunnerArguments
+from pipecat.runner.utils import create_transport
+from pipecat.services.cartesia.tts import CartesiaTTSService
+from pipecat.services.deepgram.stt import DeepgramSTTService
+from pipecat.services.openai.llm import OpenAILLMService
+from pipecat.transports.base_transport import BaseTransport, TransportParams
+
+from pipecat_memorysync import MemorySyncMemoryService
+
+load_dotenv(override=True)
+
+SYSTEM_INSTRUCTION = (
+    "You are a friendly voice assistant with long-term memory. "
+    "Relevant facts about the caller may appear as background memory context. "
+    "Use them naturally; never read them out verbatim. "
+    "Your answers are spoken aloud, so keep them short and conversational."
+)
+
+transport_params = {
+    "webrtc": lambda: TransportParams(audio_in_enabled=True, audio_out_enabled=True),
+}
+
+
+async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
+    logger.info("Starting bot")
+
+    stt = DeepgramSTTService(api_key=os.environ["DEEPGRAM_API_KEY"])
+
+    tts = CartesiaTTSService(
+        api_key=os.environ["CARTESIA_API_KEY"],
+        voice_id="71a7ad14-091c-4e8e-a314-022ece01c121",
+    )
+
+    llm = OpenAILLMService(api_key=os.environ["OPENAI_API_KEY"])
+
+    # Long-term memory. In a real deployment, derive user_id from the
+    # caller's identity (phone number, account id, ...) so each caller
+    # gets their own memories.
+    memory = MemorySyncMemoryService(
+        api_key=os.environ["MEMORYSYNC_API_KEY"],
+        user_id=os.environ.get("MEMORYSYNC_USER_ID", "demo-caller"),
+    )
+
+    context = LLMContext([{"role": "system", "content": SYSTEM_INSTRUCTION}])
+    context_aggregator = LLMContextAggregatorPair(
+        context,
+        user_params=LLMUserAggregatorParams(vad_analyzer=SileroVADAnalyzer()),
+    )
+
+    pipeline = Pipeline(
+        [
+            transport.input(),
+            stt,
+            context_aggregator.user(),
+            memory,  # enrich with memories + capture new turns, on budget
+            llm,
+            tts,
+            transport.output(),
+            context_aggregator.assistant(),
+        ]
+    )
+
+    task = PipelineTask(
+        pipeline,
+        params=PipelineParams(enable_metrics=True, enable_usage_metrics=True),
+        idle_timeout_secs=runner_args.pipeline_idle_timeout_secs,
+    )
+
+    @transport.event_handler("on_client_connected")
+    async def on_client_connected(transport, client):
+        logger.info("Client connected")
+        await task.queue_frames([LLMRunFrame()])
+
+    @transport.event_handler("on_client_disconnected")
+    async def on_client_disconnected(transport, client):
+        logger.info("Client disconnected")
+        await task.cancel()
+
+    runner = PipelineRunner(handle_sigint=runner_args.handle_sigint)
+    await runner.run(task)
+
+
+async def bot(runner_args: RunnerArguments):
+    """Main bot entry point compatible with the Pipecat runner."""
+    transport = await create_transport(runner_args, transport_params)
+    await run_bot(transport, runner_args)
+
+
+if __name__ == "__main__":
+    from pipecat.runner.run import main
+
+    main()

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.1.0}/pyproject.toml

@@ -29,7 +29,8 @@ dependencies = [
 [project.urls]
 Homepage = "https://docs.memorysync.io/guides/pipecat"
 Documentation = "https://docs.memorysync.io/guides/pipecat"
-Repository = "https://github.com/Rafay121/memorysync-plugins"
+Repository = "https://github.com/memorysyncio/memorysync-pipecat"
+Changelog = "https://github.com/memorysyncio/memorysync-pipecat/blob/main/CHANGELOG.md"
 
 [tool.hatch.version]
 path = "src/pipecat_memorysync/_version.py"

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.1.0}/src/pipecat_memorysync/_version.py

@@ -1,3 +1,3 @@
 """Version for pipecat-memorysync. Single source of truth."""
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.1.0}/src/pipecat_memorysync/service.py

@@ -7,9 +7,13 @@ predecessors don't:
 1. **Recall is budgeted.** Enrichment waits at most ``recall_timeout``
    seconds (default 1.2). On timeout or failure the context frame passes
    through unenriched — a voice reply is never stalled by a slow network.
-2. **Capture is delta-only.** Each turn stores only the messages that are
-   NEW since the last frame, verbatim, with cross-adapter fnv1a64
-   idempotency seeds — not the whole conversation re-sent every turn.
+2. **Capture is turn-complete and delta-only.** Voice aggregators split
+   one utterance across several context messages at speech pauses; this
+   service merges consecutive new user fragments and stores them as ONE
+   verbatim turn once the assistant's reply marks the turn complete (the
+   in-progress tail is flushed at end of call). Only NEW messages are
+   considered each frame — never the whole conversation re-sent — and
+   every stored turn carries a cross-adapter fnv1a64 idempotency seed.
 3. **Nothing raises, nothing is dropped.** Every failure path logs and
    pushes the ORIGINAL frame through. The pipeline cannot stall and the
    LLM always gets its context.
@@ -137,6 +141,14 @@ class MemorySyncMemoryService(FrameProcessor):
         self.params = params
 
         self._stored_seeds: Set[str] = set()
+        # Message-level consumption ledger: which context messages have
+        # been merged into a stored turn. Distinct from _stored_seeds
+        # (which dedups at merged-turn granularity) so a failed store can
+        # release its messages for re-capture on the next frame.
+        self._seen_messages: Set[str] = set()
+        # Snapshot of the in-progress user utterance (fragments after the
+        # last assistant reply) — flushed as one turn at end of call.
+        self._tail_pending: List[tuple[str, str]] = []
         self._store_tasks: Set[asyncio.Task] = set()
         self._last_query: Optional[str] = None
 
@@ -237,11 +249,25 @@ class MemorySyncMemoryService(FrameProcessor):
         body = "\n".join(lines)
         return f"{self.params.system_prompt}\n{body}\n\n{CONTEXT_GUARD}"
 
-    # ── capture: delta-only, background ────────────────────────────────
+    # ── capture: turn-complete, delta-only, background ─────────────────
 
     def _capture_delta(self, context: Any) -> None:
-        """Queue storage for messages NOT seen before. O(new), not O(all)."""
+        """Queue storage for completed turns built from NEW messages only.
+
+        Voice aggregators append each speech fragment as its own user
+        message ("Do you know that my favorite", "dinner", "and", …).
+        Storing them individually floods memory with junk rows, so:
+
+        - consecutive NEW user messages merge into ONE turn, stored the
+          moment an assistant message follows them (turn completed);
+        - user messages after the last assistant reply are an in-progress
+          utterance — they stay pending (snapshotted for the end-of-call
+          flush) instead of being stored piecemeal;
+        - NEW assistant messages store immediately, flushing any pending
+          user group first so ordering survives.
+        """
         header = self.params.system_prompt
+        entries: List[tuple[str, str]] = []  # (speaker_role, trimmed_text)
         for message in context.get_messages():
             role = message.get("role")
             if role not in ("user", "assistant"):
@@ -251,19 +277,78 @@ class MemorySyncMemoryService(FrameProcessor):
                 continue  # our own injection (user-role mode) never re-enters
             speaker_role = "human" if role == "user" else "ai"
             trimmed = text if len(text) <= MAX_TURN_CHARS else text[:MAX_TURN_CHARS] + "…"
-            seed = f"{speaker_role}:{trimmed}"
-            if seed in self._stored_seeds:
-                continue
-            self._stored_seeds.add(seed)
-            if len(self._stored_seeds) > 4096:
-                self._stored_seeds.clear()
-            # Plain asyncio tasks, tracked locally: pipeline teardown must
-            # not cancel a persist mid-flight — _flush owns their fate.
-            task = asyncio.create_task(self._store_turn(speaker_role, trimmed, seed))
-            self._store_tasks.add(task)
-            task.add_done_callback(self._store_tasks.discard)
-
-    async def _store_turn(self, speaker_role: str, text: str, seed: str) -> None:
+            entries.append((speaker_role, trimmed))
+
+        last_ai = -1
+        for index, (speaker_role, _text) in enumerate(entries):
+            if speaker_role == "ai":
+                last_ai = index
+
+        group_texts: List[str] = []
+        group_keys: List[str] = []
+        for index, (speaker_role, text) in enumerate(entries):
+            key = f"{speaker_role}:{text}"
+            if speaker_role == "human":
+                if index > last_ai:
+                    continue  # in-progress utterance — tail snapshot below
+                if key in self._seen_messages:
+                    continue
+                group_texts.append(text)
+                group_keys.append(key)
+            else:
+                if group_texts:
+                    self._store_merged(group_texts, group_keys)
+                    group_texts, group_keys = [], []
+                if key not in self._seen_messages:
+                    self._seen_messages.add(key)
+                    self._bound_seen()
+                    self._queue_store("ai", text, [key])
+
+        self._tail_pending = [
+            (text, f"human:{text}")
+            for speaker_role, text in entries[last_ai + 1:]
+            if speaker_role == "human" and f"human:{text}" not in self._seen_messages
+        ]
+
+    def _store_merged(self, texts: List[str], keys: List[str]) -> None:
+        """One utterance from its fragments: mark consumed, merge, store."""
+        for key in keys:
+            self._seen_messages.add(key)
+        self._bound_seen()
+        merged = " ".join(texts)
+        if len(merged) > MAX_TURN_CHARS:
+            merged = merged[:MAX_TURN_CHARS] + "…"
+        self._queue_store("human", merged, keys)
+
+    def _flush_tail(self) -> None:
+        """Store the in-progress utterance (end-of-call, no reply coming)."""
+        if not self._tail_pending:
+            return
+        texts = [text for text, _key in self._tail_pending]
+        keys = [key for _text, key in self._tail_pending]
+        self._tail_pending = []
+        self._store_merged(texts, keys)
+
+    def _bound_seen(self) -> None:
+        if len(self._seen_messages) > 4096:
+            self._seen_messages.clear()
+
+    def _queue_store(self, speaker_role: str, text: str, msg_keys: List[str]) -> None:
+        seed = f"{speaker_role}:{text}"
+        if seed in self._stored_seeds:
+            return
+        self._stored_seeds.add(seed)
+        if len(self._stored_seeds) > 4096:
+            self._stored_seeds.clear()
+        # Plain asyncio tasks, tracked locally: pipeline teardown must
+        # not cancel a persist mid-flight — _flush owns their fate.
+        task = asyncio.create_task(self._store_turn(speaker_role, text, seed, msg_keys))
+        self._store_tasks.add(task)
+        task.add_done_callback(self._store_tasks.discard)
+
+    async def _store_turn(
+        self, speaker_role: str, text: str, seed: str, msg_keys: List[str]
+    ) -> None:
         try:
             tenant = await self._api.resolve_tenant_id()
             await self._api.add_turn(
@@ -274,7 +359,11 @@ class MemorySyncMemoryService(FrameProcessor):
                 metadata={"session_id": self.scope},
             )
         except Exception as exc:  # noqa: BLE001
-            self._stored_seeds.discard(seed)  # the write never landed; retry later
+            # The write never landed: release both ledgers so the next
+            # frame re-captures these messages and retries the store.
+            self._stored_seeds.discard(seed)
+            for key in msg_keys:
+                self._seen_messages.discard(key)
             logger.debug(f"memorysync: store failed: {exc}")
 
     # ── conveniences (outside the pipeline) ───────────────────────────
@@ -303,7 +392,12 @@ class MemorySyncMemoryService(FrameProcessor):
     # ── lifecycle ──────────────────────────────────────────────────────
 
     async def _flush(self, *, timeout: float) -> None:
-        """Let queued stores land, bounded. Never raises."""
+        """Store the in-progress utterance, then let queued stores land,
+        bounded. Never raises."""
+        try:
+            self._flush_tail()
+        except Exception:  # noqa: BLE001
+            pass
         pending = [t for t in self._store_tasks if not t.done()]
         if not pending:
             return

{pipecat_memorysync-1.0.0 → pipecat_memorysync-1.1.0}/tests/test_service.py

@@ -28,12 +28,20 @@ def context_of(messages: List[dict]) -> LLMContext:
 
 
 async def drive(service: Any, *contexts: LLMContext) -> None:
-    """Send one LLMContextFrame per context through the real harness."""
+    """Send one LLMContextFrame per context through the real harness.
+
+    ``start_timeout`` defaults to 1s inside pipecat's harness, which the
+    FIRST test in the session routinely blows on a cold shared CI runner
+    (import machinery + task spin-up), failing it with a TimeoutError
+    before any frame flows. A generous ceiling costs nothing when the
+    pipeline starts fast — it is not a sleep — and removes the flake.
+    """
     frames = [LLMContextFrame(context=ctx) for ctx in contexts]
     await run_test(
         service,
         frames_to_send=frames,
         expected_down_frames=[LLMContextFrame] * len(frames),
+        start_timeout=30.0,
     )
 
 
@@ -242,3 +250,75 @@ async def test_conveniences_answer(mock, make_service):
 async def test_missing_user_id_is_loud_at_construction(mock):
     with pytest.raises(ValueError, match="user_id"):
         MemorySyncMemoryService(api_key="ms_x", user_id="", transport=mock.transport())
+
+
+# ── capture: turn-complete merging (voice fragmenting) ────────────────
+
+
+async def test_speech_fragments_merge_into_one_turn(mock, make_service):
+    """VAD pauses split one utterance across context messages — they must
+    store as ONE merged row when the assistant reply completes the turn,
+    never as per-fragment junk rows ("and", "dinner", …)."""
+    service = make_service()
+    fragments = [
+        "Do you know that my favorite",
+        "dinner",
+        "and",
+        "dinner is my favorite dish is biryani.",
+    ]
+    # The aggregator's view grows frame by frame while the user speaks…
+    growing = [
+        context_of([{"role": "user", "content": f} for f in fragments[: i + 1]])
+        for i in range(len(fragments))
+    ]
+    # …and the turn completes when the assistant replies.
+    completed = context_of(
+        [{"role": "user", "content": f} for f in fragments]
+        + [{"role": "assistant", "content": "Got it, biryani it is!"}]
+    )
+    await drive(service, *growing, completed)
+    await drain(mock, 2)
+
+    texts = sorted(r["text"] for r in mock.rows)
+    assert texts == [
+        "ai: Got it, biryani it is!",
+        "human: Do you know that my favorite dinner and dinner is my favorite dish is biryani.",
+    ]
+    assert mock.add_turn_calls() == 2, "four fragments + one reply = exactly two rows"
+
+
+async def test_in_progress_utterance_flushes_once_at_end_of_call(mock, make_service):
+    """A call that ends mid-utterance (no reply coming) must not lose the
+    tail — and must store it merged, not per fragment."""
+    service = make_service()
+    ctx1 = context_of([{"role": "user", "content": "my name is Abdullah"}])
+    ctx2 = context_of([
+        {"role": "user", "content": "my name is Abdullah"},
+        {"role": "user", "content": "and my favorite color is black"},
+    ])
+    await drive(service, ctx1, ctx2)  # run_test's EndFrame triggers the flush
+    await drain(mock, 1)
+
+    assert [r["text"] for r in mock.rows] == [
+        "human: my name is Abdullah and my favorite color is black"
+    ]
+    assert mock.add_turn_calls() == 1
+
+
+async def test_failed_store_releases_fragments_for_retry(mock, make_service):
+    """A store that never landed must not consume its messages — the next
+    frame re-captures and retries, converging on one row."""
+    service = make_service()
+    mock.fail_next = 503
+    turn = [
+        {"role": "user", "content": "remember that I fly out of Hyderabad"},
+        {"role": "assistant", "content": "Noted!"},
+    ]
+    await drive(service, context_of(turn))
+    await asyncio.sleep(0.3)  # the 503 lands on exactly one of the two stores
+
+    await drive(service, context_of(turn))  # same context re-seen → retry
+    await drain(mock, 2)
+
+    texts = sorted(r["text"] for r in mock.rows)
+    assert texts == ["ai: Noted!", "human: remember that I fly out of Hyderabad"]