remdb 0.3.219__tar.gz → 0.3.221__tar.gz

remdb-0.3.221/.kreuzberg/mime/939a167803029f56.msgpack

@@ -0,0 +1 @@
+��type�str�data�application/pdf�cached_at�A�Ua���H

{remdb-0.3.219 → remdb-0.3.221}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remdb
-Version: 0.3.219
+Version: 0.3.221
 Summary: Resources Entities Moments - Bio-inspired memory system for agentic AI workloads
 Project-URL: Homepage, https://github.com/Percolation-Labs/reminiscent
 Project-URL: Documentation, https://github.com/Percolation-Labs/reminiscent/blob/main/README.md

{remdb-0.3.219 → remdb-0.3.221}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "remdb"
-version = "0.3.219"
+version = "0.3.221"
 description = "Resources Entities Moments - Bio-inspired memory system for agentic AI workloads"
 readme = "README.md"
 authors = [

{remdb-0.3.219 → remdb-0.3.221}/src/rem/agentic/mcp/tool_wrapper.py

@@ -116,7 +116,7 @@ def create_resource_tool(uri: str, usage: str = "", mcp_server: Any = None) -> T
     the artificial MCP distinction between tools and resources.
 
     Supports both:
-    - Concrete URIs: "rem://schemas" -> tool with no parameters
+    - Concrete URIs: "rem://agents" -> tool with no parameters
     - Template URIs: "patient-profile://field/{field_key}" -> tool with field_key parameter
 
     Args:
@@ -131,7 +131,7 @@ def create_resource_tool(uri: str, usage: str = "", mcp_server: Any = None) -> T
 
     Example:
         # Concrete URI -> no-param tool
-        tool = create_resource_tool("rem://schemas", "List all agent schemas")
+        tool = create_resource_tool("rem://agents", "List all agent schemas")
 
         # Template URI -> parameterized tool
         tool = create_resource_tool("patient-profile://field/{field_key}", "Get field definition", mcp_server=mcp)

{remdb-0.3.219 → remdb-0.3.221}/src/rem/agentic/providers/pydantic_ai.py

@@ -732,7 +732,7 @@ async def create_agent(
     # the artificial MCP distinction between tools and resources
     #
     # Supports both concrete and template URIs:
-    # - Concrete: "rem://schemas" -> no-param tool
+    # - Concrete: "rem://agents" -> no-param tool
     # - Template: "patient-profile://field/{field_key}" -> tool with field_key param
     from ..mcp.tool_wrapper import create_resource_tool
 

{remdb-0.3.219 → remdb-0.3.221}/src/rem/agentic/schema.py

@@ -79,7 +79,7 @@ class MCPResourceReference(BaseModel):
 
     Example (exact URI):
         {
-            "uri": "rem://schemas",
+            "uri": "rem://agents",
             "name": "Agent Schemas",
             "description": "List all available agent schemas"
         }
@@ -96,7 +96,7 @@ class MCPResourceReference(BaseModel):
         default=None,
         description=(
             "Exact resource URI or URI with query parameters. "
-            "Examples: 'rem://schemas', 'rem://resources?category=drug.*'"
+            "Examples: 'rem://agents', 'rem://resources?category=drug.*'"
         )
     )
 

{remdb-0.3.219 → remdb-0.3.221}/src/rem/api/mcp_router/tools.py

@@ -594,15 +594,18 @@ async def read_resource(uri: str) -> dict[str, Any]:
     **Available Resources:**
 
     Agent Schemas:
-    • rem://schemas - List all agent schemas
-    • rem://schema/{name} - Get specific schema definition
-    • rem://schema/{name}/{version} - Get specific version
+    • rem://agents - List all available agent schemas
+    • rem://agents/{agent_name} - Get specific agent schema
+
+    Documentation:
+    • rem://schema/entities - Entity schemas (Resource, Message, User, File, Moment)
+    • rem://schema/query-types - REM query type documentation
 
     System Status:
     • rem://status - System health and statistics
 
     Args:
-        uri: Resource URI (e.g., "rem://schemas", "rem://schema/ask_rem")
+        uri: Resource URI (e.g., "rem://agents", "rem://agents/ask_rem")
 
     Returns:
         Dict with:
@@ -611,14 +614,11 @@ async def read_resource(uri: str) -> dict[str, Any]:
         - data: Resource data (format depends on resource type)
 
     Examples:
-        # List all schemas
-        read_resource(uri="rem://schemas")
-
-        # Get specific schema
-        read_resource(uri="rem://schema/ask_rem")
+        # List all agents
+        read_resource(uri="rem://agents")
 
-        # Get schema version
-        read_resource(uri="rem://schema/ask_rem/v1.0.0")
+        # Get specific agent
+        read_resource(uri="rem://agents/ask_rem")
 
         # Check system status
         read_resource(uri="rem://status")
@@ -1385,8 +1385,10 @@ async def ask_agent(
     logger.info(f"Invoking agent '{agent_name}' with prompt: {prompt[:100]}...")
 
     # Check if we have an event sink for streaming
-    event_sink = get_event_sink()
-    use_streaming = event_sink is not None
+    push_event = get_event_sink()
+    use_streaming = push_event is not None
+
+    streamed_content = ""  # Track if content was streamed
 
     try:
         # Set child context for nested tool calls
@@ -1412,12 +1414,12 @@ async def ask_agent(
                             if Agent.is_model_request_node(node):
                                 async with node.stream(agent_run.ctx) as request_stream:
                                     async for event in request_stream:
-                                        # Proxy tool call starts
+                                        # Proxy part starts
                                         if isinstance(event, PartStartEvent):
                                             from pydantic_ai.messages import ToolCallPart, TextPart
                                             if isinstance(event.part, ToolCallPart):
                                                 # Push tool start event to parent
-                                                await push_event({
+                                                await push_event.put({
                                                     "type": "child_tool_start",
                                                     "agent_name": agent_name,
                                                     "tool_name": event.part.tool_name,
@@ -1427,16 +1429,27 @@ async def ask_agent(
                                                     "tool_name": event.part.tool_name,
                                                     "index": event.index,
                                                 })
-                                        # Accumulate text content (don't push events - let parent relay text_response)
+                                            elif isinstance(event.part, TextPart):
+                                                # TextPart may have initial content
+                                                if event.part.content:
+                                                    accumulated_content.append(event.part.content)
+                                                    await push_event.put({
+                                                        "type": "child_content",
+                                                        "agent_name": agent_name,
+                                                        "content": event.part.content,
+                                                    })
+                                        # Proxy text content deltas to parent for real-time streaming
                                         elif isinstance(event, PartDeltaEvent):
                                             if hasattr(event, 'delta') and hasattr(event.delta, 'content_delta'):
                                                 content = event.delta.content_delta
                                                 if content:
                                                     accumulated_content.append(content)
-                                                    # NOTE: We no longer push child_content events here.
-                                                    # Instead, the complete response is returned as text_response
-                                                    # and the parent agent relays it. This avoids duplicate
-                                                    # emissions and keeps the parent in control of streaming.
+                                                    # Push content chunk to parent for streaming
+                                                    await push_event.put({
+                                                        "type": "child_content",
+                                                        "agent_name": agent_name,
+                                                        "content": content,
+                                                    })
 
                             elif Agent.is_call_tools_node(node):
                                 async with node.stream(agent_run.ctx) as tools_stream:
@@ -1444,7 +1457,7 @@ async def ask_agent(
                                         if isinstance(tool_event, FunctionToolResultEvent):
                                             result_content = tool_event.result.content if hasattr(tool_event.result, 'content') else tool_event.result
                                             # Push tool result to parent
-                                            await push_event({
+                                            await push_event.put({
                                                 "type": "child_tool_result",
                                                 "agent_name": agent_name,
                                                 "result": result_content,
@@ -1482,14 +1495,20 @@ async def ask_agent(
 
     logger.info(f"Agent '{agent_name}' completed successfully")
 
-    return {
+    response = {
         "status": "success",
         "output": output,
-        "text_response": str(result.output),
         "agent_schema": agent_name,
         "input_text": input_text,
     }
 
+    # Only include text_response if content was NOT streamed
+    # When streaming, child_content events already delivered the content
+    if not use_streaming or not streamed_content:
+        response["text_response"] = str(result.output)
+
+    return response
+
 
 # =============================================================================
 # Test/Debug Tools (for development only)

{remdb-0.3.219 → remdb-0.3.221}/src/rem/api/routers/chat/streaming.py

@@ -169,8 +169,6 @@ async def stream_openai_response(
     responding_agent: str | None = None
     # Track pending tool calls with full data for persistence
     # Maps tool_id -> {"tool_name": str, "tool_id": str, "arguments": dict}
-    # Track accumulated content for child event streaming
-    accumulated_content: list[str] = []
     pending_tool_data: dict[str, dict] = {}
 
     # Import context functions for multi-agent support
@@ -468,7 +466,6 @@ async def stream_openai_response(
                                                 ],
                                             )
                                             is_first_chunk = False
-                                            accumulated_content.append(content)
                                             yield f"data: {content_chunk.model_dump_json()}\n\n"
                                     elif event_type == "child_tool_result":
                                         # Emit child tool completion
@@ -579,48 +576,10 @@ async def stream_openai_response(
                                     del pending_tool_data[tool_id]
 
                                 if not is_metadata_event:
-                                    # Check for text_response in tool result (multi-agent delegation)
-                                    # When an orchestrator delegates via ask_agent, the child agent's
-                                    # text_response should be streamed as the parent's assistant content
-                                    #
-                                    # IMPORTANT: Only emit if we haven't already streamed via event sink!
-                                    # Child agents push child_content events during execution, which are
-                                    # already emitted above. Don't duplicate by emitting text_response again.
-                                    if isinstance(result_content, dict) and result_content.get("text_response"):
-                                        text_response = result_content["text_response"]
-                                        if text_response and str(text_response).strip():
-                                            # Skip if already streamed via child_content events
-                                            if accumulated_content:
-                                                logger.debug(
-                                                    f"Skipping text_response from {tool_name} - already streamed "
-                                                    f"{len(accumulated_content)} chunks via event sink"
-                                                )
-                                            else:
-                                                # No event sink streaming happened - emit the full text_response
-                                                text_content = str(text_response)
-                                                token_count += len(text_content.split())
-
-                                                # Emit as streamed content (OpenAI-compatible format)
-                                                content_chunk = ChatCompletionStreamResponse(
-                                                    id=request_id,
-                                                    created=created_at,
-                                                    model=model,
-                                                    choices=[
-                                                        ChatCompletionStreamChoice(
-                                                            index=0,
-                                                            delta=ChatCompletionMessageDelta(
-                                                                role="assistant" if is_first_chunk else None,
-                                                                content=text_content,
-                                                            ),
-                                                            finish_reason=None,
-                                                        )
-                                                    ],
-                                                )
-                                                is_first_chunk = False
-                                                yield f"data: {content_chunk.model_dump_json()}\n\n"
-                                                logger.debug(
-                                                    f"Streamed text_response from {tool_name} ({len(text_content)} chars)"
-                                                )
+                                    # NOTE: text_response fallback is DISABLED
+                                    # Child agents now stream content via child_content events (above)
+                                    # which provides real-time streaming. The text_response in tool
+                                    # result would duplicate that content, so we skip it entirely.
 
                                     # Normal tool completion - emit ToolCallEvent
                                     # For finalize_intake, send full result dict for frontend

{remdb-0.3.219 → remdb-0.3.221}/src/rem/schemas/agents/rem.yaml

@@ -124,7 +124,7 @@ json_schema_extra:
 
   # Explicit resource declarations for reference data
   resources:
-    - uri: rem://schemas
+    - uri: rem://agents
       name: Agent Schemas List
       description: List all available agent schemas in the system
     - uri: rem://status

{remdb-0.3.219 → remdb-0.3.221}/tests/integration/test_agent_delegation_streaming.py

@@ -185,7 +185,10 @@ async def test_child_agent_response_is_streamed(session_id):
             if delta.get("content"):
                 print(f"  [{i}] Content: {delta.get('content')[:50]}...")
         elif "type" in event:
-            print(f"  [{i}] Event type: {event.get('type')}")
+            event_type = event.get('type')
+            print(f"  [{i}] Event type: {event_type}")
+            if event_type == "error":
+                print(f"      ERROR: {event.get('message', event)}")
 
     # Verify we got content from the child agent
     assert content, "No content was streamed"

remdb-0.3.221/tests/integration/test_ask_agent_streaming.py

@@ -0,0 +1,38 @@
+"""Minimal test for ask_agent streaming."""
+import asyncio
+import pytest
+from rem.agentic.context import AgentContext, agent_context_scope, set_event_sink
+from rem.api.mcp_router.tools import ask_agent
+
+
+@pytest.mark.asyncio
+@pytest.mark.llm
+async def test_ask_agent_streams_child_content():
+    """ask_agent should push child_content events to the queue."""
+    queue: asyncio.Queue = asyncio.Queue()
+    ctx = AgentContext(user_id="test", tenant_id="test", session_id="test", default_model="openai:gpt-4o-mini")
+
+    set_event_sink(queue)
+    try:
+        with agent_context_scope(ctx):
+            result = await ask_agent(agent_name="rem", input_text="Say: hello")
+    finally:
+        set_event_sink(None)
+
+    # Collect events
+    events = []
+    while not queue.empty():
+        events.append(await queue.get())
+
+    print(f"\nEvents: {len(events)}")
+    for e in events:
+        print(f"  {e.get('type')}: {str(e)[:80]}")
+    print(f"\nResult: {result}")
+
+    # Must have child_content events
+    content_events = [e for e in events if e.get("type") == "child_content"]
+    assert len(content_events) > 0, f"No child_content events! Got: {events}"
+
+    # text_response should NOT be in result if content was streamed
+    if "text_response" in result:
+        print(f"\n⚠ text_response present (duplication source): {result['text_response'][:50]}...")

{remdb-0.3.219 → remdb-0.3.221}/tests/unit/test_resource_tools.py

@@ -14,10 +14,10 @@ class TestCreateResourceTool:
 
     def test_concrete_uri_creates_no_param_tool(self):
         """Concrete URIs become tools with no parameters."""
-        tool = create_resource_tool("rem://schemas", "List all schemas")
+        tool = create_resource_tool("rem://agents", "List all agents")
 
-        assert tool.name == "get_rem_schemas"
-        assert "List all schemas" in (tool.description or "")
+        assert tool.name == "get_rem_agents"
+        assert "List all agents" in (tool.description or "")
 
     def test_template_uri_creates_parameterized_tool(self):
         """Template URIs become tools with extracted parameters."""
@@ -95,12 +95,12 @@ class TestResourceToolExecution:
             return_value={"schemas": ["agent1", "agent2"]}
         )
 
-        tool = create_resource_tool("rem://schemas", "List schemas")
+        tool = create_resource_tool("rem://agents", "List agents")
 
         # Get the wrapper function and call it
         result = await tool.function()
 
-        mock_load.assert_called_once_with("rem://schemas")
+        mock_load.assert_called_once_with("rem://agents")
         assert "agent1" in result
 
     async def test_template_tool_substitutes_params(self, mocker):

remdb-0.3.219/tests/integration/test_ask_agent_streaming.py

@@ -1,279 +0,0 @@
-"""
-Real end-to-end test for ask_agent streaming at the controller level.
-
-Tests that when an orchestrator agent delegates to a child via ask_agent:
-1. Child agent events are streamed/bubbled up to the parent
-2. All tool calls are saved to database
-3. Assistant message is saved to database
-
-NO MOCKING - uses real agents and real database.
-
-Run with:
-    POSTGRES__CONNECTION_STRING="postgresql://rem:rem@localhost:5050/rem" \
-    uv run pytest tests/integration/test_ask_agent_streaming.py -v -s
-"""
-
-import asyncio
-import json
-import uuid
-import pytest
-from pathlib import Path
-
-# Mark these tests as requiring LLM calls - they can be skipped in pre-push hooks
-# Also mark them as needing isolation due to nested async resource management
-pytestmark = [
-    pytest.mark.llm,  # Requires real LLM API calls
-    pytest.mark.asyncio,  # Uses async/await
-]
-
-from rem.agentic.context import AgentContext
-from rem.agentic.providers.pydantic_ai import create_agent
-from rem.utils.schema_loader import load_agent_schema
-from rem.api.routers.chat.streaming import stream_openai_response_with_save
-from rem.services.session import SessionMessageStore
-from rem.settings import settings
-
-
-# Path to test agent schemas
-TEST_SCHEMAS_DIR = Path(__file__).parent.parent / "data" / "schemas" / "agents"
-
-
-class TestAskAgentStreaming:
-    """
-    Real end-to-end tests for ask_agent streaming.
-
-    Uses test_orchestrator (always calls ask_agent) and test_responder (simple responder).
-    """
-
-    @pytest.fixture
-    def session_id(self):
-        return str(uuid.uuid4())
-
-    @pytest.fixture
-    def user_id(self):
-        return str(uuid.uuid4())
-
-    @pytest.mark.asyncio
-    async def test_ask_agent_streams_and_saves(self, session_id, user_id):
-        """
-        Test that ask_agent properly streams child content and saves all messages.
-
-        Expected flow:
-        1. Orchestrator calls ask_agent(agent_name="rem", input_text=...)
-        2. Child agent (rem) responds with text
-        3. Child's text is streamed as content chunks
-        4. Tool call (ask_agent) is saved to database
-        5. Assistant message (child's response) is saved to database
-        """
-        if not settings.postgres.enabled:
-            pytest.skip("Postgres not enabled - set POSTGRES__CONNECTION_STRING")
-
-        # Load the test_orchestrator schema
-        schema_path = TEST_SCHEMAS_DIR / "test_orchestrator.yaml"
-        schema = load_agent_schema(str(schema_path))
-        assert schema is not None, "test_orchestrator schema not found"
-
-        # Use OpenAI model for testing
-        test_model = "openai:gpt-4.1"
-
-        # Create context
-        context = AgentContext(
-            user_id=user_id,
-            session_id=session_id,
-            tenant_id=user_id,
-            default_model=test_model,
-        )
-
-        # Create agent with OpenAI model
-        agent = await create_agent(context=context, agent_schema_override=schema, model_override=test_model)
-
-        # Collect streaming output
-        chunks = []
-        content_chunks = []
-        tool_events = []
-
-        # Use OpenAI model for testing (Anthropic has credit issues)
-        test_model = "openai:gpt-4.1"
-
-        async for chunk in stream_openai_response_with_save(
-            agent=agent,
-            prompt="Hello, please delegate this message",
-            model=test_model,
-            session_id=session_id,
-            user_id=user_id,
-            agent_context=context,
-        ):
-            chunks.append(chunk)
-
-            # Parse chunk to categorize
-            if chunk.startswith("data: ") and not chunk.startswith("data: [DONE]"):
-                try:
-                    data = json.loads(chunk[6:].strip())
-                    if "choices" in data:
-                        delta = data["choices"][0].get("delta", {})
-                        content = delta.get("content")
-                        if content:
-                            content_chunks.append(content)
-                except json.JSONDecodeError:
-                    pass
-            elif chunk.startswith("event: tool_call"):
-                tool_events.append(chunk)
-
-        # Print results for debugging
-        print(f"\n=== STREAMING RESULTS ===")
-        print(f"Total chunks: {len(chunks)}")
-        print(f"Content chunks: {len(content_chunks)}")
-        print(f"Tool events: {len(tool_events)}")
-        print(f"Streamed content: {''.join(content_chunks)[:200]}...")
-
-        # Load saved messages from database
-        store = SessionMessageStore(user_id=user_id)
-        messages = await store.load_session_messages(session_id=session_id, user_id=user_id)
-
-        print(f"\n=== SAVED MESSAGES ===")
-        for msg in messages:
-            role = msg.get("role", "?")
-            content = str(msg.get("content", ""))[:80]
-            tool_name = msg.get("tool_name", "")
-            print(f"  {role}: {content}{'...' if len(str(msg.get('content', ''))) > 80 else ''} {f'[{tool_name}]' if tool_name else ''}")
-
-        # Categorize saved messages
-        tool_msgs = [m for m in messages if m.get("role") == "tool"]
-        assistant_msgs = [m for m in messages if m.get("role") == "assistant"]
-        ask_agent_tools = [m for m in tool_msgs if m.get("tool_name") == "ask_agent"]
-
-        print(f"\n=== SUMMARY ===")
-        print(f"Tool messages: {len(tool_msgs)}")
-        print(f"ask_agent tools: {len(ask_agent_tools)}")
-        print(f"Assistant messages: {len(assistant_msgs)}")
-
-        # ASSERTIONS
-        # 1. Content should have been streamed
-        assert len(content_chunks) > 0, "No content was streamed"
-        streamed_content = "".join(content_chunks)
-        assert len(streamed_content) > 0, "Streamed content is empty"
-
-        # 2. ask_agent tool call should be saved
-        assert len(ask_agent_tools) >= 1, f"Expected at least 1 ask_agent tool message, got {len(ask_agent_tools)}"
-
-        # 3. Assistant message should be saved
-        assert len(assistant_msgs) == 1, f"Expected 1 assistant message, got {len(assistant_msgs)}"
-
-        # 4. Assistant message should contain the streamed content
-        # Note: Saved content may be compressed/formatted differently
-        saved_content = assistant_msgs[0].get("content", "")
-        print(f"\n=== CONTENT COMPARISON ===")
-        print(f"Streamed length: {len(streamed_content)}")
-        print(f"Saved length: {len(saved_content)}")
-        print(f"Streamed first 100: {streamed_content[:100]}...")
-        print(f"Saved first 100: {saved_content[:100]}...")
-        # Check that they share common content (may differ due to formatting)
-        assert len(saved_content) > 0, "Saved content is empty"
-        # Relaxed check - just verify content is substantial
-        assert len(saved_content) > 50, f"Saved content too short: {len(saved_content)}"
-
-        print("\n✅ All assertions passed!")
-
-
-    @pytest.mark.asyncio
-    async def test_multi_turn_saves_all_assistant_messages(self, session_id, user_id):
-        """
-        Test that multiple turns in the same session each save their own assistant message.
-
-        This catches bugs like accumulated_content not being properly scoped per-turn.
-        The bug would manifest as: turn 1 works, turn 2+ fails with NameError.
-
-        Expected: N turns -> N assistant messages saved to database.
-        """
-        if not settings.postgres.enabled:
-            pytest.skip("Postgres not enabled - set POSTGRES__CONNECTION_STRING")
-
-        # Use a simple responder agent (no delegation) to isolate multi-turn streaming
-        schema_path = TEST_SCHEMAS_DIR / "test_responder.yaml"
-        schema = load_agent_schema(str(schema_path))
-        assert schema is not None, "test_responder schema not found"
-
-        test_model = "openai:gpt-4.1"
-
-        # Create context
-        context = AgentContext(
-            user_id=user_id,
-            session_id=session_id,
-            tenant_id=user_id,
-            default_model=test_model,
-        )
-
-        # Create agent
-        agent = await create_agent(context=context, agent_schema_override=schema, model_override=test_model)
-
-        # Run 3 turns - simple conversation
-        turn_prompts = [
-            "Hello, how are you?",
-            "Tell me something interesting",
-            "Thanks for chatting!",
-        ]
-
-        for turn_num, prompt in enumerate(turn_prompts, 1):
-            print(f"\n=== TURN {turn_num}: {prompt[:50]}... ===")
-
-            chunks = []
-            async for chunk in stream_openai_response_with_save(
-                agent=agent,
-                prompt=prompt,
-                model=test_model,
-                session_id=session_id,
-                user_id=user_id,
-                agent_context=context,
-            ):
-                chunks.append(chunk)
-
-            print(f"Turn {turn_num} completed: {len(chunks)} chunks")
-
-            # Verify no errors occurred (would manifest as fewer chunks or exception)
-            assert len(chunks) > 0, f"Turn {turn_num} produced no chunks"
-
-        # Load saved messages from database
-        store = SessionMessageStore(user_id=user_id)
-        messages = await store.load_session_messages(session_id=session_id, user_id=user_id)
-
-        # Categorize saved messages
-        assistant_msgs = [m for m in messages if m.get("role") == "assistant"]
-
-        print(f"\n=== MULTI-TURN RESULTS ===")
-        print(f"Total messages: {len(messages)}")
-        print(f"Assistant messages: {len(assistant_msgs)}")
-
-        for i, msg in enumerate(assistant_msgs):
-            content = str(msg.get("content", ""))[:60]
-            print(f"  Assistant {i+1}: {content}...")
-
-        # CRITICAL ASSERTION: Each turn should save an assistant message
-        assert len(assistant_msgs) == len(turn_prompts), (
-            f"Expected {len(turn_prompts)} assistant messages for {len(turn_prompts)} turns, "
-            f"got {len(assistant_msgs)}. This indicates a per-turn scoping bug."
-        )
-
-        # Verify each assistant message has content
-        for i, msg in enumerate(assistant_msgs):
-            content = msg.get("content", "")
-            assert len(content) > 0, f"Assistant message {i+1} has no content"
-
-        print("\n✅ Multi-turn test passed!")
-
-
-if __name__ == "__main__":
-    # Run directly for quick testing
-    async def main():
-        test = TestAskAgentStreaming()
-        session_id = str(uuid.uuid4())
-        user_id = str(uuid.uuid4())
-
-        print("Running test_ask_agent_streams_and_saves...")
-        await test.test_ask_agent_streams_and_saves(session_id, user_id)
-
-        print("\n" + "="*60)
-        print("Running test_multi_turn_saves_all_assistant_messages...")
-        session_id = str(uuid.uuid4())  # Fresh session
-        await test.test_multi_turn_saves_all_assistant_messages(session_id, user_id)
-
-    asyncio.run(main())