remdb 0.3.180__py3-none-any.whl → 0.3.230__py3-none-any.whl

rem/api/routers/chat/completions.py

@@ -164,7 +164,7 @@ from .models import (
     ChatCompletionUsage,
     ChatMessage,
 )
-from .streaming import stream_openai_response, stream_openai_response_with_save, stream_simulator_response
+from .streaming import stream_openai_response, stream_openai_response_with_save, stream_simulator_response, save_user_message
 
 router = APIRouter(prefix="/api/v1", tags=["chat"])
 
@@ -215,7 +215,7 @@ async def ensure_session_with_metadata(
     Merges request metadata with existing session metadata.
 
     Args:
-        session_id: Session identifier (maps to Session.name)
+        session_id: Session UUID from X-Session-Id header
         user_id: User identifier
         tenant_id: Tenant identifier
         is_eval: Whether this is an evaluation session
@@ -228,12 +228,8 @@ async def ensure_session_with_metadata(
     try:
         repo = Repository(Session, table_name="sessions")
 
-        # Try to load existing session by name (session_id is the name field)
-        existing_list = await repo.find(
-            filters={"name": session_id, "tenant_id": tenant_id},
-            limit=1,
-        )
-        existing = existing_list[0] if existing_list else None
+        # Look up session by UUID (id field)
+        existing = await repo.get_by_id(session_id)
 
         if existing:
             # Merge metadata if provided
@@ -254,9 +250,10 @@ async def ensure_session_with_metadata(
                 await repo.upsert(existing)
                 logger.debug(f"Updated session {session_id} (eval={is_eval}, metadata keys={list(merged_metadata.keys())})")
         else:
-            # Create new session
+            # Create new session with the provided UUID as the id
             session = Session(
-                name=session_id,
+                id=session_id,  # Use the provided UUID as session id
+                name=session_id,  # Default name to UUID, can be updated later with LLM-generated name
                 mode=SessionMode.EVALUATION if is_eval else SessionMode.NORMAL,
                 user_id=user_id,
                 tenant_id=tenant_id,
@@ -503,16 +500,51 @@ async def chat_completions(body: ChatCompletionRequest, request: Request):
             logger.error(f"Failed to transcribe audio: {e}")
             # Fall through with original content (will likely fail at agent)
 
-    # Use ContextBuilder to construct complete message list with:
-    # 1. System context hint (date + user profile)
-    # 2. Session history (if session_id provided)
-    # 3. New messages from request body (transcribed if audio)
+    # Use ContextBuilder to construct context and basic messages
+    # Note: We load session history separately for proper pydantic-ai message_history
     context, messages = await ContextBuilder.build_from_headers(
         headers=dict(request.headers),
         new_messages=new_messages,
         user_id=temp_context.user_id,  # From JWT token (source of truth)
     )
 
+    # Load raw session history for proper pydantic-ai message_history format
+    # This enables proper tool call/return pairing for LLM API compatibility
+    from ....services.session import SessionMessageStore, session_to_pydantic_messages, audit_session_history
+    from ....agentic.schema import get_system_prompt
+
+    pydantic_message_history = None
+    if context.session_id and settings.postgres.enabled:
+        try:
+            store = SessionMessageStore(user_id=context.user_id or settings.test.effective_user_id)
+            raw_session_history = await store.load_session_messages(
+                session_id=context.session_id,
+                user_id=context.user_id,
+                compress_on_load=False,  # Don't compress - we need full data for reconstruction
+            )
+            if raw_session_history:
+                # CRITICAL: Extract and pass the agent's system prompt
+                # pydantic-ai only auto-adds system prompts when message_history is empty
+                # When we pass message_history, we must include the system prompt ourselves
+                agent_system_prompt = get_system_prompt(agent_schema) if agent_schema else None
+                pydantic_message_history = session_to_pydantic_messages(
+                    raw_session_history,
+                    system_prompt=agent_system_prompt,
+                )
+                logger.debug(f"Converted {len(raw_session_history)} session messages to {len(pydantic_message_history)} pydantic-ai messages (with system prompt)")
+
+                # Audit session history if enabled (for debugging)
+                audit_session_history(
+                    session_id=context.session_id,
+                    agent_name=schema_name or "default",
+                    prompt=body.messages[-1].content if body.messages else "",
+                    raw_session_history=raw_session_history,
+                    pydantic_messages_count=len(pydantic_message_history),
+                )
+        except Exception as e:
+            logger.warning(f"Failed to load session history for message_history: {e}")
+            # Fall back to old behavior (concatenated prompt)
+
     logger.info(f"Built context with {len(messages)} total messages (includes history + user context)")
 
     # Ensure session exists with metadata and eval mode if applicable
@@ -533,33 +565,30 @@ async def chat_completions(body: ChatCompletionRequest, request: Request):
         model_override=body.model,  # type: ignore[arg-type]
     )
 
-    # Combine all messages into single prompt for agent
-    # ContextBuilder already assembled: system context + history + new messages
-    prompt = "\n".join(msg.content for msg in messages)
+    # Build the prompt for the agent
+    # If we have proper message_history, use just the latest user message as prompt
+    # Otherwise, fall back to concatenating all messages (legacy behavior)
+    if pydantic_message_history:
+        # Use the latest user message as the prompt, with history passed separately
+        user_prompt = body.messages[-1].content if body.messages else ""
+        prompt = user_prompt
+        logger.debug(f"Using message_history with {len(pydantic_message_history)} messages")
+    else:
+        # Legacy: Combine all messages into single prompt for agent
+        prompt = "\n".join(msg.content for msg in messages)
 
     # Generate OpenAI-compatible request ID
     request_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
 
     # Streaming mode
     if body.stream:
-        # Save user message before streaming starts
-        if settings.postgres.enabled and context.session_id:
-            user_message = {
-                "role": "user",
-                "content": body.messages[-1].content if body.messages else "",
-                "timestamp": datetime.utcnow().isoformat(),
-            }
-            try:
-                store = SessionMessageStore(user_id=context.user_id or settings.test.effective_user_id)
-                await store.store_session_messages(
-                    session_id=context.session_id,
-                    messages=[user_message],
-                    user_id=context.user_id,
-                    compress=False,  # User messages are typically short
-                )
-                logger.debug(f"Saved user message to session {context.session_id}")
-            except Exception as e:
-                logger.error(f"Failed to save user message: {e}", exc_info=True)
+        # Save user message before streaming starts (using shared utility)
+        if context.session_id:
+            await save_user_message(
+                session_id=context.session_id,
+                user_id=context.user_id,
+                content=body.messages[-1].content if body.messages else "",
+            )
 
         return StreamingResponse(
             stream_openai_response_with_save(
@@ -570,6 +599,8 @@ async def chat_completions(body: ChatCompletionRequest, request: Request):
                 agent_schema=schema_name,
                 session_id=context.session_id,
                 user_id=context.user_id,
+                agent_context=context,  # Pass context for multi-agent support
+                message_history=pydantic_message_history,  # Native pydantic-ai message history
             ),
             media_type="text/event-stream",
             headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
@@ -592,10 +623,16 @@ async def chat_completions(body: ChatCompletionRequest, request: Request):
         ) as span:
             # Capture trace context from the span we just created
             trace_id, span_id = get_current_trace_context()
-            result = await agent.run(prompt)
+            if pydantic_message_history:
+                result = await agent.run(prompt, message_history=pydantic_message_history)
+            else:
+                result = await agent.run(prompt)
     else:
         # No tracer available, run without tracing
-        result = await agent.run(prompt)
+        if pydantic_message_history:
+            result = await agent.run(prompt, message_history=pydantic_message_history)
+        else:
+            result = await agent.run(prompt)
 
     # Determine content format based on response_format request
     if body.response_format and body.response_format.type == "json_object":

rem/api/routers/chat/sse_events.py

@@ -321,7 +321,11 @@ class MetadataEvent(BaseModel):
     # Agent info
     agent_schema: str | None = Field(
         default=None,
-        description="Name of the agent schema used for this response (e.g., 'rem', 'query-assistant')"
+        description="Name of the top-level agent schema (e.g., 'siggy', 'rem')"
+    )
+    responding_agent: str | None = Field(
+        default=None,
+        description="Name of the agent that produced this response (may differ from agent_schema if delegated via ask_agent)"
     )
 
     # Session info
@@ -409,9 +413,9 @@ class ToolCallEvent(BaseModel):
         default=None,
         description="Tool arguments (for 'started' status)"
     )
-    result: str | None = Field(
+    result: str | dict[str, Any] | None = Field(
         default=None,
-        description="Tool result summary (for 'completed' status)"
+        description="Tool result - full dict for finalize_intake, summary string for others"
     )
     error: str | None = Field(
         default=None,