remdb 0.3.202__py3-none-any.whl → 0.3.245__py3-none-any.whl

rem/api/mcp_router/resources.py

@@ -542,6 +542,227 @@ def register_status_resources(mcp: FastMCP):
 """
 
 
+def register_session_resources(mcp: FastMCP):
+    """
+    Register session resources for loading conversation history.
+
+    Args:
+        mcp: FastMCP server instance
+    """
+
+    @mcp.resource("rem://sessions/{session_id}")
+    async def get_session_messages(session_id: str) -> str:
+        """
+        Load a conversation session by ID.
+
+        Returns the full message history including user messages, assistant responses,
+        and tool calls. Useful for evaluators and analysis agents.
+
+        Args:
+            session_id: Session UUID or identifier
+
+        Returns:
+            Formatted conversation history as markdown string with:
+            - Message type (user/assistant/tool)
+            - Content
+            - Timestamps
+            - Tool call details (if any)
+        """
+        from ...services.postgres import get_postgres_service
+
+        pg = get_postgres_service()
+        await pg.connect()
+
+        try:
+            # Query messages for session
+            query = """
+            SELECT id, message_type, content, metadata, created_at
+            FROM messages
+            WHERE session_id = $1
+            ORDER BY created_at ASC
+            """
+            messages = await pg.fetch(query, session_id)
+
+            if not messages:
+                return f"# Session Not Found\n\nNo messages found for session_id: {session_id}"
+
+            # Format output
+            output = [f"# Session: {session_id}\n"]
+            output.append(f"**Total messages:** {len(messages)}\n")
+
+            for i, msg in enumerate(messages, 1):
+                msg_type = msg['message_type']
+                content = msg['content'] or "(empty)"
+                created = msg['created_at']
+                metadata = msg.get('metadata') or {}
+
+                # Format based on message type
+                if msg_type == 'user':
+                    output.append(f"\n## [{i}] USER ({created})")
+                    output.append(f"```\n{content[:1000]}{'...' if len(content) > 1000 else ''}\n```")
+                elif msg_type == 'assistant':
+                    output.append(f"\n## [{i}] ASSISTANT ({created})")
+                    output.append(f"```\n{content[:1000]}{'...' if len(content) > 1000 else ''}\n```")
+                elif msg_type == 'tool':
+                    tool_name = metadata.get('tool_name', 'unknown')
+                    output.append(f"\n## [{i}] TOOL: {tool_name} ({created})")
+                    # Truncate tool results more aggressively
+                    output.append(f"```json\n{content[:500]}{'...' if len(content) > 500 else ''}\n```")
+                else:
+                    output.append(f"\n## [{i}] {msg_type.upper()} ({created})")
+                    output.append(f"```\n{content[:500]}{'...' if len(content) > 500 else ''}\n```")
+
+            return "\n".join(output)
+
+        finally:
+            await pg.disconnect()
+
+    @mcp.resource("rem://sessions")
+    async def list_recent_sessions() -> str:
+        """
+        List recent sessions with basic info.
+
+        Returns the most recent 20 sessions with:
+        - Session ID
+        - First user message (preview)
+        - Message count
+        - Timestamp
+        """
+        from ...services.postgres import get_postgres_service
+
+        pg = get_postgres_service()
+        await pg.connect()
+
+        try:
+            # Query recent sessions
+            query = """
+            SELECT
+                session_id,
+                MIN(created_at) as started_at,
+                COUNT(*) as message_count,
+                MIN(CASE WHEN message_type = 'user' THEN content END) as first_message
+            FROM messages
+            WHERE session_id IS NOT NULL
+            GROUP BY session_id
+            ORDER BY MIN(created_at) DESC
+            LIMIT 20
+            """
+            sessions = await pg.fetch(query)
+
+            if not sessions:
+                return "# Recent Sessions\n\nNo sessions found."
+
+            output = ["# Recent Sessions\n"]
+            output.append(f"Showing {len(sessions)} most recent sessions:\n")
+
+            for session in sessions:
+                session_id = session['session_id']
+                started = session['started_at']
+                count = session['message_count']
+                first_msg = session['first_message'] or "(no user message)"
+                preview = first_msg[:80] + "..." if len(first_msg) > 80 else first_msg
+
+                output.append(f"\n## {session_id}")
+                output.append(f"- **Started:** {started}")
+                output.append(f"- **Messages:** {count}")
+                output.append(f"- **First message:** {preview}")
+                output.append(f"- **Load:** `rem://sessions/{session_id}`")
+
+            return "\n".join(output)
+
+        finally:
+            await pg.disconnect()
+
+
+def register_user_resources(mcp: FastMCP):
+    """
+    Register user profile resources for on-demand profile loading.
+
+    Args:
+        mcp: FastMCP server instance
+    """
+
+    @mcp.resource("user://profile/{user_id}")
+    async def get_user_profile(user_id: str) -> str:
+        """
+        Load a user's profile by ID.
+
+        Returns the user's profile information including:
+        - Email and name
+        - Summary (AI-generated profile summary)
+        - Interests and preferred topics
+        - Activity level
+
+        This resource is protected - each user can only access their own profile.
+        The user_id should match the authenticated user's ID from the JWT token.
+
+        Args:
+            user_id: User UUID from authentication
+
+        Returns:
+            Formatted user profile as markdown string, or error if not found
+        """
+        from ...services.postgres import get_postgres_service
+        from ...services.postgres.repository import Repository
+        from ...models.entities.user import User
+
+        pg = get_postgres_service()
+        await pg.connect()
+
+        try:
+            user_repo = Repository(User, "users", db=pg)
+            # Look up user by ID (user_id from JWT is the primary key)
+            user = await user_repo.get_by_id(user_id, tenant_id=None)
+
+            if not user:
+                return f"# User Profile Not Found\n\nNo user found with ID: {user_id}"
+
+            # Build profile output
+            output = [f"# User Profile: {user.name or user.email or 'Unknown'}"]
+            output.append("")
+
+            if user.email:
+                output.append(f"**Email:** {user.email}")
+
+            if user.role:
+                output.append(f"**Role:** {user.role}")
+
+            if user.tier:
+                output.append(f"**Tier:** {user.tier.value if hasattr(user.tier, 'value') else user.tier}")
+
+            if user.summary:
+                output.append(f"\n## Summary\n{user.summary}")
+
+            if user.interests:
+                output.append(f"\n## Interests\n- " + "\n- ".join(user.interests[:10]))
+
+            if user.preferred_topics:
+                output.append(f"\n## Preferred Topics\n- " + "\n- ".join(user.preferred_topics[:10]))
+
+            if user.activity_level:
+                output.append(f"\n**Activity Level:** {user.activity_level}")
+
+            if user.last_active_at:
+                output.append(f"**Last Active:** {user.last_active_at}")
+
+            # Add metadata if present (but redact sensitive fields)
+            if user.metadata:
+                safe_metadata = {k: v for k, v in user.metadata.items()
+                               if k not in ('login_code', 'password', 'token', 'secret')}
+                if safe_metadata:
+                    output.append(f"\n## Additional Info")
+                    for key, value in list(safe_metadata.items())[:5]:
+                        output.append(f"- **{key}:** {value}")
+
+            return "\n".join(output)
+
+        except Exception as e:
+            return f"# Error Loading Profile\n\nFailed to load user profile: {e}"
+
+        finally:
+            await pg.disconnect()
+
+
 # Resource dispatcher for read_resource tool
 async def load_resource(uri: str) -> dict | str:
     """
@@ -571,6 +792,8 @@ async def load_resource(uri: str) -> dict | str:
     register_agent_resources(mcp)
     register_file_resources(mcp)
     register_status_resources(mcp)
+    register_session_resources(mcp)
+    register_user_resources(mcp)
 
     # 1. Try exact match in regular resources
     resources = await mcp.get_resources()

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")
@@ -1265,7 +1265,7 @@ async def ask_agent(
     """
     import asyncio
     from ...agentic import create_agent
-    from ...agentic.context import get_current_context, agent_context_scope
+    from ...agentic.context import get_current_context, agent_context_scope, get_event_sink, push_event
     from ...agentic.agents.agent_manager import get_agent
     from ...utils.schema_loader import load_agent_schema
 
@@ -1342,16 +1342,162 @@ async def ask_agent(
     if input_data:
         prompt = f"{input_text}\n\nInput data: {json.dumps(input_data)}"
 
+    # Load session history for the sub-agent (CRITICAL for multi-turn conversations)
+    # Sub-agents need to see the full conversation context, not just the summary
+    pydantic_message_history = None
+    if child_context.session_id and settings.postgres.enabled:
+        try:
+            from ...services.session import SessionMessageStore, session_to_pydantic_messages
+            from ...agentic.schema import get_system_prompt
+
+            store = SessionMessageStore(user_id=child_context.user_id or "default")
+            raw_session_history = await store.load_session_messages(
+                session_id=child_context.session_id,
+                user_id=child_context.user_id,
+                compress_on_load=False,  # Need full data for reconstruction
+            )
+            if raw_session_history:
+                # Extract agent's system prompt from schema
+                agent_system_prompt = get_system_prompt(schema) if schema else None
+                pydantic_message_history = session_to_pydantic_messages(
+                    raw_session_history,
+                    system_prompt=agent_system_prompt,
+                )
+                logger.debug(
+                    f"ask_agent '{agent_name}': loaded {len(raw_session_history)} session messages "
+                    f"-> {len(pydantic_message_history)} pydantic-ai messages"
+                )
+
+                # Audit session history if enabled
+                from ...services.session import audit_session_history
+                audit_session_history(
+                    session_id=child_context.session_id,
+                    agent_name=agent_name,
+                    prompt=prompt,
+                    raw_session_history=raw_session_history,
+                    pydantic_messages_count=len(pydantic_message_history),
+                )
+        except Exception as e:
+            logger.warning(f"ask_agent '{agent_name}': failed to load session history: {e}")
+            # Fall back to running without history
+
     # Run agent with timeout and context propagation
     logger.info(f"Invoking agent '{agent_name}' with prompt: {prompt[:100]}...")
 
+    # Check if we have an event sink for streaming
+    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
         with agent_context_scope(child_context):
-            result = await asyncio.wait_for(
-                agent_runtime.run(prompt),
-                timeout=timeout_seconds
-            )
+            if use_streaming:
+                # STREAMING MODE: Use iter() and proxy events to parent
+                logger.debug(f"ask_agent '{agent_name}': using streaming mode with event proxying")
+
+                async def run_with_streaming():
+                    from pydantic_ai.messages import (
+                        PartStartEvent, PartDeltaEvent, PartEndEvent,
+                        FunctionToolResultEvent, FunctionToolCallEvent,
+                    )
+                    from pydantic_ai.agent import Agent
+
+                    accumulated_content = []
+                    child_tool_calls = []
+
+                    # iter() returns an async context manager, not an awaitable
+                    iter_kwargs = {"message_history": pydantic_message_history} if pydantic_message_history else {}
+                    async with agent_runtime.iter(prompt, **iter_kwargs) as agent_run:
+                        async for node in agent_run:
+                            if Agent.is_model_request_node(node):
+                                async with node.stream(agent_run.ctx) as request_stream:
+                                    async for event in request_stream:
+                                        # Proxy part starts (text content only - tool calls handled in is_call_tools_node)
+                                        if isinstance(event, PartStartEvent):
+                                            from pydantic_ai.messages import ToolCallPart, TextPart
+                                            if isinstance(event.part, ToolCallPart):
+                                                # Track tool call for later (args are incomplete at PartStartEvent)
+                                                # Full args come via FunctionToolCallEvent in is_call_tools_node
+                                                child_tool_calls.append({
+                                                    "tool_name": event.part.tool_name,
+                                                    "index": event.index,
+                                                })
+                                            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)
+                                                    # 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:
+                                    async for tool_event in tools_stream:
+                                        # FunctionToolCallEvent fires when tool call is parsed
+                                        # with complete arguments (before execution)
+                                        if isinstance(tool_event, FunctionToolCallEvent):
+                                            # Get full arguments from completed tool call
+                                            tool_args = None
+                                            if hasattr(tool_event, 'part') and hasattr(tool_event.part, 'args'):
+                                                raw_args = tool_event.part.args
+                                                if isinstance(raw_args, str):
+                                                    try:
+                                                        tool_args = json.loads(raw_args)
+                                                    except json.JSONDecodeError:
+                                                        tool_args = {"raw": raw_args}
+                                                elif isinstance(raw_args, dict):
+                                                    tool_args = raw_args
+                                            # Push tool start with full arguments
+                                            await push_event.put({
+                                                "type": "child_tool_start",
+                                                "agent_name": agent_name,
+                                                "tool_name": tool_event.part.tool_name if hasattr(tool_event, 'part') else "unknown",
+                                                "arguments": tool_args,
+                                            })
+                                        elif 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.put({
+                                                "type": "child_tool_result",
+                                                "agent_name": agent_name,
+                                                "result": result_content,
+                                            })
+
+                        # Get final result (inside context manager)
+                        return agent_run.result, "".join(accumulated_content), child_tool_calls
+
+                result, streamed_content, tool_calls = await asyncio.wait_for(
+                    run_with_streaming(),
+                    timeout=timeout_seconds
+                )
+            else:
+                # NON-STREAMING MODE: Use run() for backwards compatibility
+                if pydantic_message_history:
+                    result = await asyncio.wait_for(
+                        agent_runtime.run(prompt, message_history=pydantic_message_history),
+                        timeout=timeout_seconds
+                    )
+                else:
+                    result = await asyncio.wait_for(
+                        agent_runtime.run(prompt),
+                        timeout=timeout_seconds
+                    )
     except asyncio.TimeoutError:
         return {
             "status": "error",
@@ -1365,14 +1511,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)

rem/api/routers/admin.py

@@ -31,6 +31,8 @@ from fastapi import APIRouter, Depends, Header, HTTPException, Query, Background
 from loguru import logger
 from pydantic import BaseModel
 
+from .common import ErrorResponse
+
 from ..deps import require_admin
 from ...models.entities import Message, Session, SessionMode
 from ...services.postgres import Repository
@@ -103,7 +105,13 @@ class SystemStats(BaseModel):
 # =============================================================================
 
 
-@router.get("/users", response_model=UserListResponse)
+@router.get(
+    "/users",
+    response_model=UserListResponse,
+    responses={
+        503: {"model": ErrorResponse, "description": "Database not enabled"},
+    },
+)
 async def list_all_users(
     user: dict = Depends(require_admin),
     limit: int = Query(default=50, ge=1, le=100),
@@ -155,7 +163,13 @@ async def list_all_users(
     return UserListResponse(data=summaries, total=total, has_more=has_more)
 
 
-@router.get("/sessions", response_model=SessionListResponse)
+@router.get(
+    "/sessions",
+    response_model=SessionListResponse,
+    responses={
+        503: {"model": ErrorResponse, "description": "Database not enabled"},
+    },
+)
 async def list_all_sessions(
     user: dict = Depends(require_admin),
     user_id: str | None = Query(default=None, description="Filter by user ID"),
@@ -202,7 +216,13 @@ async def list_all_sessions(
     return SessionListResponse(data=sessions, total=total, has_more=has_more)
 
 
-@router.get("/messages", response_model=MessageListResponse)
+@router.get(
+    "/messages",
+    response_model=MessageListResponse,
+    responses={
+        503: {"model": ErrorResponse, "description": "Database not enabled"},
+    },
+)
 async def list_all_messages(
     user: dict = Depends(require_admin),
     user_id: str | None = Query(default=None, description="Filter by user ID"),
@@ -252,7 +272,13 @@ async def list_all_messages(
     return MessageListResponse(data=messages, total=total, has_more=has_more)
 
 
-@router.get("/stats", response_model=SystemStats)
+@router.get(
+    "/stats",
+    response_model=SystemStats,
+    responses={
+        503: {"model": ErrorResponse, "description": "Database not enabled"},
+    },
+)
 async def get_system_stats(
     user: dict = Depends(require_admin),
 ) -> SystemStats: