remdb 0.3.230__py3-none-any.whl → 0.3.258__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

@@ -1414,17 +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 part starts
+                                        # 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):
-                                                # Push tool start event to parent
-                                                await push_event.put({
-                                                    "type": "child_tool_start",
-                                                    "agent_name": agent_name,
-                                                    "tool_name": event.part.tool_name,
-                                                    "arguments": event.part.args if hasattr(event.part, 'args') else None,
-                                                })
+                                                # 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,
@@ -1454,7 +1449,28 @@ async def ask_agent(
                             elif Agent.is_call_tools_node(node):
                                 async with node.stream(agent_run.ctx) as tools_stream:
                                     async for tool_event in tools_stream:
-                                        if isinstance(tool_event, FunctionToolResultEvent):
+                                        # 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({
@@ -1490,16 +1506,66 @@ async def ask_agent(
         }
 
     # Serialize output
-    from rem.agentic.serialization import serialize_agent_result
+    from rem.agentic.serialization import serialize_agent_result, is_pydantic_model
     output = serialize_agent_result(result.output)
 
     logger.info(f"Agent '{agent_name}' completed successfully")
 
+    # If child agent returned structured output (Pydantic model), emit as tool_call SSE event
+    # This allows the frontend to render structured results (forms, cards, etc.)
+    is_structured_output = is_pydantic_model(result.output)
+    structured_tool_id = f"{agent_name}_structured_output"
+    logger.debug(f"ask_agent '{agent_name}': is_structured_output={is_structured_output}, output_type={type(result.output).__name__}")
+
+    if use_streaming and is_structured_output and push_event is not None:
+        # Emit structured output as a tool_call event with the serialized result
+        # Use agent_name as tool_name so it appears as the logical tool (e.g., "finalize_intake_agent")
+        await push_event.put({
+            "type": "tool_call",
+            "tool_name": agent_name,  # Use agent name as tool name for clarity
+            "tool_id": structured_tool_id,
+            "status": "completed",
+            "arguments": {"input_text": input_text},
+            "result": output,  # Serialized Pydantic model as dict
+        })
+        logger.debug(f"ask_agent '{agent_name}': emitted structured output as tool_call SSE event")
+
+    # Save structured output as a tool message in the database
+    # This makes structured output agents look like tool calls in session history
+    if is_structured_output and child_context and child_context.session_id and settings.postgres.enabled:
+        try:
+            from ...services.session import SessionMessageStore
+            from ...utils.date_utils import utc_now, to_iso
+
+            store = SessionMessageStore(user_id=child_context.user_id or "default")
+
+            # Build tool message in the same format as regular tool calls
+            tool_message = {
+                "role": "tool",
+                "content": json.dumps(output, default=str),  # Structured output as JSON
+                "timestamp": to_iso(utc_now()),
+                "tool_call_id": structured_tool_id,
+                "tool_name": agent_name,  # Agent name as tool name
+                "tool_arguments": {"input_text": input_text},
+            }
+
+            # Store as a single message (not using store_session_messages to avoid compression)
+            await store.store_session_messages(
+                session_id=child_context.session_id,
+                messages=[tool_message],
+                user_id=child_context.user_id,
+                compress=False,  # Don't compress tool results
+            )
+            logger.debug(f"ask_agent '{agent_name}': saved structured output as tool message in session")
+        except Exception as e:
+            logger.warning(f"ask_agent '{agent_name}': failed to save structured output to database: {e}")
+
     response = {
         "status": "success",
         "output": output,
         "agent_schema": agent_name,
         "input_text": input_text,
+        "is_structured_output": is_structured_output,  # Flag for caller to know result type
     }
 
     # Only include text_response if content was NOT streamed

rem/api/routers/auth.py

@@ -3,11 +3,12 @@ Authentication Router.
 
 Supports multiple authentication methods:
 1. Email (passwordless): POST /api/auth/email/send-code, POST /api/auth/email/verify
-2. OAuth (Google, Microsoft): GET /api/auth/{provider}/login, GET /api/auth/{provider}/callback
+2. Pre-approved codes: POST /api/auth/email/verify (with pre-approved code, no send-code needed)
+3. OAuth (Google, Microsoft): GET /api/auth/{provider}/login, GET /api/auth/{provider}/callback
 
 Endpoints:
 - POST /api/auth/email/send-code     - Send login code to email
-- POST /api/auth/email/verify        - Verify code and create session
+- POST /api/auth/email/verify        - Verify code and create session (supports pre-approved codes)
 - GET  /api/auth/{provider}/login    - Initiate OAuth flow
 - GET  /api/auth/{provider}/callback - OAuth callback
 - POST /api/auth/logout              - Clear session
@@ -15,9 +16,39 @@ Endpoints:
 
 Supported providers:
 - email: Passwordless email login
+- preapproved: Pre-approved codes (bypass email, set via AUTH__PREAPPROVED_CODES)
 - google: Google OAuth 2.0 / OIDC
 - microsoft: Microsoft Entra ID OIDC
 
+=============================================================================
+Pre-Approved Code Authentication
+=============================================================================
+
+Pre-approved codes allow login without email verification. Useful for:
+- Demo accounts
+- Testing
+- Beta access codes
+- Admin provisioning
+
+Configuration:
+    AUTH__PREAPPROVED_CODES=A12345,A67890,B11111,B22222
+
+Code prefixes:
+    A = Admin role (e.g., A12345, AADMIN1)
+    B = Normal user role (e.g., B11111, BUSER1)
+
+Flow:
+    1. User enters email + pre-approved code (no send-code step needed)
+    2. POST /api/auth/email/verify with email and code
+    3. System validates code against AUTH__PREAPPROVED_CODES
+    4. Creates user if not exists, sets role based on prefix
+    5. Returns JWT tokens (same as email auth)
+
+Example:
+    curl -X POST http://localhost:8000/api/auth/email/verify \
+      -H "Content-Type: application/json" \
+      -d '{"email": "admin@example.com", "code": "A12345"}'
+
 =============================================================================
 Email Authentication Access Control
 =============================================================================
@@ -52,7 +83,7 @@ User Tiers (models.entities.UserTier):
 
 Configuration:
     # Allow only specific domains for new signups
-    EMAIL__TRUSTED_EMAIL_DOMAINS=siggymd.ai,example.com
+    EMAIL__TRUSTED_EMAIL_DOMAINS=mycompany.com,example.com
 
     # Allow all domains (no restrictions)
     EMAIL__TRUSTED_EMAIL_DOMAINS=
@@ -242,6 +273,12 @@ async def verify_email_code(request: Request, body: EmailVerifyRequest):
     """
     Verify login code and create session with JWT tokens.
 
+    Supports two authentication methods:
+    1. Pre-approved codes: Codes from AUTH__PREAPPROVED_CODES bypass email verification.
+       - A prefix = admin role, B prefix = normal user role
+       - Creates user if not exists, logs in directly
+    2. Email verification: Standard 6-digit code sent via email
+
     Args:
         request: FastAPI request
         body: EmailVerifyRequest with email and code
@@ -249,12 +286,6 @@ async def verify_email_code(request: Request, body: EmailVerifyRequest):
     Returns:
         Success status with user info and JWT tokens
     """
-    if not settings.email.is_configured:
-        raise HTTPException(
-            status_code=501,
-            detail="Email authentication is not configured"
-        )
-
     if not settings.postgres.enabled:
         raise HTTPException(
             status_code=501,
@@ -264,6 +295,79 @@ async def verify_email_code(request: Request, body: EmailVerifyRequest):
     db = PostgresService()
     try:
         await db.connect()
+        user_service = UserService(db)
+
+        # Check for pre-approved code first
+        preapproved = settings.auth.check_preapproved_code(body.code)
+        if preapproved:
+            logger.info(f"Pre-approved code login attempt for {body.email} (role: {preapproved['role']})")
+
+            # Get or create user with pre-approved role
+            user_id = email_to_user_id(body.email)
+            user_entity = await user_service.get_user_by_id(user_id)
+
+            if not user_entity:
+                # Create new user with role from pre-approved code
+                user_entity = await user_service.get_or_create_user(
+                    email=body.email,
+                    name=body.email.split("@")[0],
+                    tenant_id="default",
+                )
+                # Update role based on pre-approved code prefix
+                user_entity.role = preapproved["role"]
+                from ...services.postgres.repository import Repository
+                from ...models.entities.user import User
+                user_repo = Repository(User, "users", db=db)
+                await user_repo.upsert(user_entity)
+                logger.info(f"Created user {body.email} with role={preapproved['role']} via pre-approved code")
+            else:
+                # Update existing user's role if admin code used
+                if preapproved["role"] == "admin" and user_entity.role != "admin":
+                    user_entity.role = "admin"
+                    from ...services.postgres.repository import Repository
+                    from ...models.entities.user import User
+                    user_repo = Repository(User, "users", db=db)
+                    await user_repo.upsert(user_entity)
+                    logger.info(f"Upgraded user {body.email} to admin via pre-approved code")
+
+            # Build user dict for session/JWT
+            user_dict = {
+                "id": str(user_entity.id),
+                "email": body.email,
+                "email_verified": True,
+                "name": user_entity.name or body.email.split("@")[0],
+                "provider": "preapproved",
+                "tenant_id": user_entity.tenant_id or "default",
+                "tier": user_entity.tier.value if user_entity.tier else "free",
+                "role": user_entity.role or preapproved["role"],
+                "roles": [user_entity.role or preapproved["role"]],
+            }
+
+            # Generate JWT tokens
+            jwt_service = get_jwt_service()
+            tokens = jwt_service.create_tokens(user_dict)
+
+            # Store user in session
+            request.session["user"] = user_dict
+
+            logger.info(f"User authenticated via pre-approved code: {body.email} (role: {user_dict['role']})")
+
+            return {
+                "success": True,
+                "message": "Successfully authenticated with pre-approved code!",
+                "user": user_dict,
+                "access_token": tokens["access_token"],
+                "refresh_token": tokens["refresh_token"],
+                "token_type": tokens["token_type"],
+                "expires_in": tokens["expires_in"],
+            }
+
+        # Standard email verification flow
+        if not settings.email.is_configured:
+            raise HTTPException(
+                status_code=501,
+                detail="Email authentication is not configured"
+            )
 
         # Initialize email auth provider
         email_auth = EmailAuthProvider()
@@ -288,7 +392,6 @@ async def verify_email_code(request: Request, body: EmailVerifyRequest):
         )
 
         # Fetch actual user data from database to get role/tier
-        user_service = UserService(db)
         try:
             user_entity = await user_service.get_user_by_id(result.user_id)
             if user_entity:

rem/api/routers/chat/child_streaming.py

@@ -5,7 +5,7 @@ Handles events from child agents during multi-agent orchestration.
 
 Event Flow:
 ```
-Parent Agent (Siggy)
+Parent Agent (Orchestrator)
       │
       ▼
   ask_agent tool
@@ -52,7 +52,7 @@ async def handle_child_tool_start(
     state: StreamingState,
     child_agent: str,
     tool_name: str,
-    arguments: dict | None,
+    arguments: dict | str | None,
     session_id: str | None,
     user_id: str | None,
 ) -> AsyncGenerator[str, None]:
@@ -62,13 +62,18 @@ async def handle_child_tool_start(
     Actions:
     1. Log the tool call
     2. Emit SSE event
-    3. Save to database
+    3. Save to database (with tool_arguments in metadata for consistency with parent)
     """
     full_tool_name = f"{child_agent}:{tool_name}"
     tool_id = f"call_{uuid.uuid4().hex[:8]}"
 
-    # Normalize arguments
-    if not isinstance(arguments, dict):
+    # Normalize arguments - may come as JSON string from ToolCallPart.args
+    if isinstance(arguments, str):
+        try:
+            arguments = json.loads(arguments)
+        except json.JSONDecodeError:
+            arguments = None
+    elif not isinstance(arguments, dict):
         arguments = None
 
     # 1. LOG
@@ -82,7 +87,7 @@ async def handle_child_tool_start(
         arguments=arguments,
     ))
 
-    # 3. SAVE TO DB
+    # 3. SAVE TO DB - content contains args as JSON (pydantic_messages.py parses it)
     if session_id and settings.postgres.enabled:
         try:
             store = SessionMessageStore(
@@ -90,9 +95,12 @@ async def handle_child_tool_start(
             )
             tool_msg = {
                 "role": "tool",
-                "tool_name": full_tool_name,
+                # Content is the tool call args as JSON - this is what the agent sees on reload
+                # and what pydantic_messages.py parses for ToolCallPart.args
                 "content": json.dumps(arguments) if arguments else "",
                 "timestamp": to_iso(utc_now()),
+                "tool_call_id": tool_id,
+                "tool_name": full_tool_name,
             }
             await store.store_session_messages(
                 session_id=session_id,
@@ -170,11 +178,17 @@ async def handle_child_tool_result(
         ))
 
     # Emit tool completion
+    # Preserve full result for dict/list types (needed for frontend)
+    if isinstance(result, (dict, list)):
+        result_for_sse = result
+    else:
+        result_for_sse = str(result) if result else None
+
     yield format_sse_event(ToolCallEvent(
         tool_name=f"{child_agent}:tool",
         tool_id=f"call_{uuid.uuid4().hex[:8]}",
         status="completed",
-        result=str(result)[:200] if result else None,
+        result=result_for_sse,
     ))
 
 

rem/api/routers/chat/completions.py

@@ -16,11 +16,11 @@ IMPORTANT: Session IDs MUST be UUIDs. Non-UUID session IDs will cause message
     kubectl port-forward -n observability svc/otel-collector-collector 4318:4318
 
     # Terminal 2: Phoenix UI - view traces at http://localhost:6006
-    kubectl port-forward -n siggy svc/phoenix 6006:6006
+    kubectl port-forward -n rem svc/phoenix 6006:6006
 
 2. Get Phoenix API Key (REQUIRED for feedback->Phoenix sync):
 
-    export PHOENIX_API_KEY=$(kubectl get secret -n siggy rem-phoenix-api-key \\
+    export PHOENIX_API_KEY=$(kubectl get secret -n rem rem-phoenix-api-key \\
       -o jsonpath='{.data.PHOENIX_API_KEY}' | base64 -d)
 
 3. Start API with OTEL and Phoenix enabled:
@@ -70,7 +70,7 @@ OTEL Architecture
 =================
 
     REM API --[OTLP/HTTP]--> OTEL Collector --[relay]--> Phoenix
-             (port 4318)    (k8s: observability)         (k8s: siggy)
+             (port 4318)    (k8s: observability)         (k8s: rem)
 
 Environment Variables:
     OTEL__ENABLED=true              Enable OTEL tracing (required for trace capture)

rem/api/routers/chat/sse_events.py

@@ -321,7 +321,7 @@ class MetadataEvent(BaseModel):
     # Agent info
     agent_schema: str | None = Field(
         default=None,
-        description="Name of the top-level agent schema (e.g., 'siggy', 'rem')"
+        description="Name of the top-level agent schema (e.g., 'rem', 'intake')"
     )
     responding_agent: str | None = Field(
         default=None,
@@ -413,9 +413,9 @@ class ToolCallEvent(BaseModel):
         default=None,
         description="Tool arguments (for 'started' status)"
     )
-    result: str | dict[str, Any] | None = Field(
+    result: str | dict[str, Any] | list[Any] | None = Field(
         default=None,
-        description="Tool result - full dict for finalize_intake, summary string for others"
+        description="Tool result - full dict/list for structured data, string for simple results"
     )
     error: str | None = Field(
         default=None,