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

rem/agentic/providers/pydantic_ai.py

@@ -357,6 +357,9 @@ def _convert_properties_to_prompt(properties: dict[str, Any]) -> str:
     definition into natural language guidance that informs the agent
     about the expected response structure without forcing JSON output.
 
+    IMPORTANT: The 'answer' field is the OUTPUT to the user. All other
+    fields are INTERNAL tracking that should NOT appear in the output.
+
     Args:
         properties: JSON Schema properties dict
 
@@ -368,45 +371,59 @@ def _convert_properties_to_prompt(properties: dict[str, Any]) -> str:
             "answer": {"type": "string", "description": "The answer"},
             "confidence": {"type": "number", "description": "Confidence 0-1"}
         }
-        # Returns:
-        # "## Response Structure\n\nYour response should include:\n- **answer**: The answer\n..."
+        # Returns guidance that only answer should be output
     """
     if not properties:
         return ""
 
-    lines = ["## Response Guidelines", "", "Your response should address the following elements:"]
-
-    for field_name, field_def in properties.items():
-        field_type = field_def.get("type", "any")
-        description = field_def.get("description", "")
-
-        # Format based on type
-        if field_type == "array":
-            type_hint = "list"
-        elif field_type == "number":
-            type_hint = "number"
-            # Include min/max if specified
-            if "minimum" in field_def or "maximum" in field_def:
-                min_val = field_def.get("minimum", "")
-                max_val = field_def.get("maximum", "")
-                if min_val != "" and max_val != "":
-                    type_hint = f"number ({min_val}-{max_val})"
-        elif field_type == "boolean":
-            type_hint = "yes/no"
-        else:
-            type_hint = field_type
+    # Separate answer (output) from other fields (internal tracking)
+    answer_field = properties.get("answer")
+    internal_fields = {k: v for k, v in properties.items() if k != "answer"}
+
+    lines = ["## Internal Thinking Structure (DO NOT output these labels)"]
+    lines.append("")
+    lines.append("Use this structure to organize your thinking, but ONLY output the answer content:")
+    lines.append("")
+
+    # If there's an answer field, emphasize it's the ONLY output
+    if answer_field:
+        answer_desc = answer_field.get("description", "Your response")
+        lines.append(f"**OUTPUT (what the user sees):** {answer_desc}")
+        lines.append("")
+
+    # Document internal fields for tracking/thinking
+    if internal_fields:
+        lines.append("**INTERNAL (for your tracking only - do NOT include in output):**")
+        for field_name, field_def in internal_fields.items():
+            field_type = field_def.get("type", "any")
+            description = field_def.get("description", "")
+
+            # Format based on type
+            if field_type == "array":
+                type_hint = "list"
+            elif field_type == "number":
+                type_hint = "number"
+                if "minimum" in field_def or "maximum" in field_def:
+                    min_val = field_def.get("minimum", "")
+                    max_val = field_def.get("maximum", "")
+                    if min_val != "" and max_val != "":
+                        type_hint = f"number ({min_val}-{max_val})"
+            elif field_type == "boolean":
+                type_hint = "yes/no"
+            else:
+                type_hint = field_type
 
-        # Build field description
-        field_line = f"- **{field_name}**"
-        if type_hint and type_hint != "string":
-            field_line += f" ({type_hint})"
-        if description:
-            field_line += f": {description}"
+            field_line = f"- {field_name}"
+            if type_hint and type_hint != "string":
+                field_line += f" ({type_hint})"
+            if description:
+                field_line += f": {description}"
 
-        lines.append(field_line)
+            lines.append(field_line)
 
     lines.append("")
-    lines.append("Respond naturally in prose, addressing these elements where relevant.")
+    lines.append("⚠️ CRITICAL: Your response must be ONLY the conversational answer text.")
+    lines.append("Do NOT output field names like 'answer:' or 'diverge_output:' - just the response itself.")
 
     return "\n".join(lines)
 
@@ -664,26 +681,26 @@ async def create_agent(
 
         set_agent_resource_attributes(agent_schema=agent_schema)
 
-    # Extract schema metadata for search_rem tool description suffix
-    # This allows entity schemas to add context-specific notes to the search_rem tool
-    search_rem_suffix = None
-    if metadata:
-        # Check for default_search_table in metadata (set by entity schemas)
-        extra = agent_schema.get("json_schema_extra", {}) if agent_schema else {}
-        default_table = extra.get("default_search_table")
-        has_embeddings = extra.get("has_embeddings", False)
-
-        if default_table:
-            # Build description suffix for search_rem
-            search_rem_suffix = f"\n\nFor this schema, use `search_rem` to query `{default_table}`. "
-            if has_embeddings:
-                search_rem_suffix += f"SEARCH works well on {default_table} (has embeddings). "
-            search_rem_suffix += f"Example: `SEARCH \"your query\" FROM {default_table} LIMIT 10`"
-
     # Add tools from MCP server (in-process, no subprocess)
     # Track loaded MCP servers for resource resolution
     loaded_mcp_server = None
 
+    # Build map of tool_name → schema description from agent schema tools section
+    # This allows agent-specific tool guidance to override/augment MCP tool descriptions
+    schema_tool_descriptions: dict[str, str] = {}
+    tool_configs = metadata.tools if metadata and hasattr(metadata, 'tools') else []
+    for tool_config in tool_configs:
+        if hasattr(tool_config, 'name'):
+            t_name = tool_config.name
+            t_desc = tool_config.description or ""
+        else:
+            t_name = tool_config.get("name", "")
+            t_desc = tool_config.get("description", "")
+        # Skip resource URIs (handled separately below)
+        if t_name and "://" not in t_name and t_desc:
+            schema_tool_descriptions[t_name] = t_desc
+            logger.debug(f"Schema tool description for '{t_name}': {len(t_desc)} chars")
+
     for server_config in mcp_server_configs:
         server_type = server_config.get("type")
         server_id = server_config.get("id", "mcp-server")
@@ -708,8 +725,8 @@ async def create_agent(
                 mcp_tools_dict = await mcp_server.get_tools()
 
                 for tool_name, tool_func in mcp_tools_dict.items():
-                    # Add description suffix to search_rem tool if schema specifies a default table
-                    tool_suffix = search_rem_suffix if tool_name == "search_rem" else None
+                    # Get schema description suffix if agent schema defines one for this tool
+                    tool_suffix = schema_tool_descriptions.get(tool_name)
 
                     wrapped_tool = create_mcp_tool_wrapper(
                         tool_name,
@@ -718,7 +735,7 @@ async def create_agent(
                         description_suffix=tool_suffix,
                     )
                     tools.append(wrapped_tool)
-                    logger.debug(f"Loaded MCP tool: {tool_name}" + (" (with schema suffix)" if tool_suffix else ""))
+                    logger.debug(f"Loaded MCP tool: {tool_name}" + (" (with schema desc)" if tool_suffix else ""))
 
                 logger.info(f"Loaded {len(mcp_tools_dict)} tools from MCP server: {server_id} (in-process)")
 

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({

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
 =============================================================================
@@ -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: