fix(memmachein): preserve conversation message order in add_items (#1856)

## Summary

- Fixes a race condition in \`MemMachineEditor.add_items\` that caused non-deterministic ordering of conversation messages and flaky CI failures on Python 3.13

## Root Cause

\`add_items\` wrapped each conversation message in \`asyncio.to_thread(add_memory)\` and dispatched all tasks concurrently via \`asyncio.gather(*tasks)\`. Thread pool tasks complete in nondeterministic order, so the API spy recorded calls by completion order rather than insertion order — causing \`test_conversation_messages_preserved_in_order\` to flip assertions under CI load.

## Fix

Refactored \`add_items\` to introduce an inner \`add_item\` coroutine per \`MemoryItem\`. Within that coroutine, conversation messages are \`await\`ed sequentially via \`asyncio.to_thread\`, preserving chronological order. Multiple \`MemoryItem\`s are still dispatched concurrently via \`asyncio.gather\` — so there is no performance regression on batch inserts.

\`\`\`python
async def add_item(memory_item: MemoryItem) -> None:
    ...
    for msg in conversation:
        await asyncio.to_thread(add_memory)   # sequential within one item

if items:
    await asyncio.gather(*(add_item(item) for item in items))  # concurrent across items
\`\`\`

The index-based assertions in the test are preserved as-is — they are now correct because the implementation guarantees order.

## Test plan

- [x] \`test_conversation_messages_preserved_in_order\` passes 50 consecutive runs on Python 3.11, 3.12, and 3.13 locally
- [x] Full test suite: 37 passed, 6 skipped (integration) on all three Python versions

Closes #1855



## Summary by CodeRabbit

* **Refactor**
  * Updated memory item upload processing to preserve the sequential order of conversation messages while maintaining concurrent processing of multiple memory items.

Authors:
  - Federico Kamelhar (https://github.com/fede-kamel)

Approvers:
  - Will Killian (https://github.com/willkill07)

URL: #1856

Author: fede-kamel

packages/nvidia_nat_memmachine/src/nat/plugins/memmachine/memmachine_editor.py

@@ -111,11 +111,14 @@ async def add_items(self, items: list[MemoryItem]) -> None:
         Each MemoryItem is translated and uploaded through the MemMachine API.
 
         All memories are added to both episodic and semantic memory types.
+
+        Conversation messages within a single MemoryItem are added sequentially to
+        preserve chronological order. Separate MemoryItems (and non-conversation
+        memories) are still dispatched concurrently via asyncio.gather.
         """
-        # Run synchronous operations in thread pool to make them async
-        tasks = []
 
-        for memory_item in items:
+        async def add_item(memory_item: MemoryItem) -> None:
+            """Upload a single MemoryItem, adding conversation messages sequentially."""
             # Make a copy of metadata to avoid modifying the original
             item_meta = memory_item.metadata.copy() if memory_item.metadata else {}
             conversation = memory_item.conversation
@@ -139,7 +142,9 @@ async def add_items(self, items: list[MemoryItem]) -> None:
             # If we have a conversation, add each message separately
             # Otherwise, use memory_text or skip if no content
             if conversation:
-                # Add each message in the conversation with its role
+                # Add each message sequentially to preserve conversation order.
+                # asyncio.to_thread tasks dispatched via gather() complete in
+                # nondeterministic order, so we await each one before the next.
                 for msg in conversation:
                     msg_role = msg.get('role', 'user')
                     msg_content = msg.get('content', '')
@@ -154,7 +159,6 @@ async def add_items(self, items: list[MemoryItem]) -> None:
                         # Convert list to comma-separated string
                         metadata["tags"] = ", ".join(tags) if isinstance(tags, list) else str(tags)
 
-                    # Capture variables in closure to avoid late binding issues
                     def add_memory(
                         content=msg_content,
                         role=msg_role,
@@ -173,8 +177,7 @@ def add_memory(
                             episode_type=None  # Use default (MESSAGE)
                         )
 
-                    task = asyncio.to_thread(add_memory)
-                    tasks.append(task)
+                    await asyncio.to_thread(add_memory)
             elif memory_text:
                 # Add as a single memory item (direct memory without conversation)
                 # Add tags to metadata if present
@@ -195,11 +198,10 @@ def add_memory(content=memory_text, mem=memory, meta=metadata, mem_types=memory_
                         episode_type=None  # Use default (MESSAGE)
                     )
 
-                task = asyncio.to_thread(add_memory)
-                tasks.append(task)
+                await asyncio.to_thread(add_memory)
 
-        if tasks:
-            await asyncio.gather(*tasks)
+        if items:
+            await asyncio.gather(*(add_item(item) for item in items))
 
     async def search(self, query: str, top_k: int = 5, **kwargs) -> list[MemoryItem]:
         """