remdb 0.2.6__py3-none-any.whl → 0.3.118__py3-none-any.whl

rem/api/routers/auth.py

@@ -49,6 +49,8 @@ from authlib.integrations.starlette_client import OAuth
 from loguru import logger
 
 from ...settings import settings
+from ...services.postgres.service import PostgresService
+from ...services.user_service import UserService
 
 router = APIRouter(prefix="/api/auth", tags=["auth"])
 
@@ -168,6 +170,53 @@ async def callback(provider: str, request: Request):
         if not user_info:
             # Fetch from userinfo endpoint if not in ID token
             user_info = await client.userinfo(token=token)
+            
+        # --- REM Integration Start ---
+        if settings.postgres.enabled:
+            # Connect to DB
+            db = PostgresService()
+            try:
+                await db.connect()
+                user_service = UserService(db)
+                
+                # Get/Create User
+                user_entity = await user_service.get_or_create_user(
+                    email=user_info.get("email"),
+                    name=user_info.get("name", "New User"),
+                    avatar_url=user_info.get("picture"),
+                    tenant_id="default", # Single tenant for now
+                )
+                
+                # Link Anonymous Session
+                # TrackingMiddleware sets request.state.anon_id
+                anon_id = getattr(request.state, "anon_id", None)
+                # Fallback to cookie if middleware didn't run or state missing
+                if not anon_id:
+                    # Attempt to parse cookie manually if needed, but middleware 
+                    # usually handles the signature logic.
+                    # Just check raw cookie for simple case (not recommended if signed)
+                    pass 
+                
+                if anon_id:
+                    await user_service.link_anonymous_session(user_entity, anon_id)
+                    
+                # Enrich session user with DB info
+                db_info = {
+                    "id": str(user_entity.id),
+                    "tenant_id": user_entity.tenant_id,
+                    "tier": user_entity.tier.value if user_entity.tier else "free",
+                    "roles": [user_entity.role] if user_entity.role else [],
+                }
+                
+            except Exception as db_e:
+                logger.error(f"Database error during auth callback: {db_e}")
+                # Continue login even if DB fails, but warn
+                db_info = {"id": "db_error", "tier": "free"}
+            finally:
+                await db.disconnect()
+        else:
+            db_info = {"id": "no_db", "tier": "free"}
+        # --- REM Integration End ---
 
         # Store user info in session
         request.session["user"] = {
@@ -176,6 +225,11 @@ async def callback(provider: str, request: Request):
             "email": user_info.get("email"),
             "name": user_info.get("name"),
             "picture": user_info.get("picture"),
+            # Add DB info
+            "id": db_info.get("id"),
+            "tenant_id": db_info.get("tenant_id", "default"),
+            "tier": db_info.get("tier"),
+            "roles": db_info.get("roles", []),
         }
 
         # Store tokens in session for API access
@@ -227,3 +281,73 @@ async def me(request: Request):
         raise HTTPException(status_code=401, detail="Not authenticated")
 
     return user
+
+
+# =============================================================================
+# Development Token Endpoints (non-production only)
+# =============================================================================
+
+
+def generate_dev_token() -> str:
+    """
+    Generate a dev token for testing.
+
+    Token format: dev_<hmac_signature>
+    The signature is based on the session secret to ensure only valid tokens work.
+    """
+    import hashlib
+    import hmac
+
+    # Use session secret as key
+    secret = settings.auth.session_secret or "dev-secret"
+    message = "test-user:dev-token"
+
+    signature = hmac.new(
+        secret.encode(),
+        message.encode(),
+        hashlib.sha256
+    ).hexdigest()[:32]
+
+    return f"dev_{signature}"
+
+
+def verify_dev_token(token: str) -> bool:
+    """Verify a dev token is valid."""
+    expected = generate_dev_token()
+    return token == expected
+
+
+@router.get("/dev/token")
+async def get_dev_token(request: Request):
+    """
+    Get a development token for testing (non-production only).
+
+    This token can be used as a Bearer token to authenticate as the
+    test user (test-user / test@rem.local) without going through OAuth.
+
+    Usage:
+        curl -H "Authorization: Bearer <token>" http://localhost:8000/api/v1/...
+
+    Returns:
+        401 if in production environment
+        Token and usage instructions otherwise
+    """
+    if settings.environment == "production":
+        raise HTTPException(
+            status_code=401,
+            detail="Dev tokens are not available in production"
+        )
+
+    token = generate_dev_token()
+
+    return {
+        "token": token,
+        "type": "Bearer",
+        "user": {
+            "id": "test-user",
+            "email": "test@rem.local",
+            "name": "Test User",
+        },
+        "usage": f'curl -H "Authorization: Bearer {token}" http://localhost:8000/api/v1/...',
+        "warning": "This token is for development/testing only and will not work in production.",
+    }

rem/api/routers/chat/completions.py

@@ -70,7 +70,7 @@ from ....agentic.providers.pydantic_ai import create_agent
 from ....services.audio.transcriber import AudioTranscriber
 from ....services.session import SessionMessageStore, reload_session
 from ....settings import settings
-from ....utils.schema_loader import load_agent_schema
+from ....utils.schema_loader import load_agent_schema, load_agent_schema_async
 from .json_utils import extract_json_resilient
 from .models import (
     ChatCompletionChoice,
@@ -79,9 +79,9 @@ from .models import (
     ChatCompletionUsage,
     ChatMessage,
 )
-from .streaming import stream_openai_response
+from .streaming import stream_openai_response, stream_openai_response_with_save, stream_simulator_response
 
-router = APIRouter(prefix="/v1", tags=["chat"])
+router = APIRouter(prefix="/api/v1", tags=["chat"])
 
 # Default agent schema file
 DEFAULT_AGENT_SCHEMA = "rem"
@@ -133,9 +133,114 @@ async def chat_completions(body: ChatCompletionRequest, request: Request):
     temp_context = AgentContext.from_headers(dict(request.headers))
     schema_name = temp_context.agent_schema_uri or DEFAULT_AGENT_SCHEMA
 
+    # Resolve model: use body.model if provided, otherwise settings default
+    if body.model is None:
+        body.model = settings.llm.default_model
+        logger.debug(f"No model specified, using default: {body.model}")
+
+    # Special handling for simulator schema - no LLM, just generates demo SSE events
+    # Check BEFORE loading schema since simulator doesn't need a schema file
+    # Still builds full context and saves messages like a real agent
+    if schema_name == "simulator":
+        logger.info("Using SSE simulator (no LLM)")
+
+        # Build context just like real agents (loads session history, user context)
+        new_messages = [msg.model_dump() for msg in body.messages]
+        context, messages = await ContextBuilder.build_from_headers(
+            headers=dict(request.headers),
+            new_messages=new_messages,
+        )
+
+        # Get the last user message as prompt
+        prompt = body.messages[-1].content if body.messages else "demo"
+        request_id = f"sim-{uuid.uuid4().hex[:24]}"
+
+        # Generate message IDs upfront for correlation
+        user_message_id = str(uuid.uuid4())
+        assistant_message_id = str(uuid.uuid4())
+
+        # Simulated assistant response content (for persistence)
+        simulated_content = (
+            f"[SSE Simulator Response]\n\n"
+            f"This is a simulated response demonstrating all SSE event types:\n"
+            f"- reasoning events (model thinking)\n"
+            f"- text_delta events (streamed content)\n"
+            f"- progress events (multi-step operations)\n"
+            f"- tool_call events (function invocations)\n"
+            f"- action_request events (UI solicitation)\n"
+            f"- metadata events (confidence, sources, message IDs)\n\n"
+            f"Original prompt: {prompt[:100]}{'...' if len(prompt) > 100 else ''}"
+        )
+
+        # Save messages to database (if session_id and postgres enabled)
+        if settings.postgres.enabled and context.session_id:
+            user_message = {
+                "id": user_message_id,
+                "role": "user",
+                "content": prompt,
+                "timestamp": datetime.utcnow().isoformat(),
+            }
+            assistant_message = {
+                "id": assistant_message_id,
+                "role": "assistant",
+                "content": simulated_content,
+                "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, assistant_message],
+                    user_id=context.user_id,
+                    compress=True,
+                )
+                logger.info(f"Saved simulator conversation to session {context.session_id}")
+            except Exception as e:
+                # Log error but don't fail the request - session storage is non-critical
+                logger.error(f"Failed to save session messages: {e}", exc_info=True)
+
+        if body.stream:
+            return StreamingResponse(
+                stream_simulator_response(
+                    prompt=prompt,
+                    model="simulator-v1.0.0",
+                    # Pass message correlation IDs
+                    message_id=assistant_message_id,
+                    in_reply_to=user_message_id,
+                    session_id=context.session_id,
+                ),
+                media_type="text/event-stream",
+                headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+            )
+        else:
+            # Non-streaming simulator returns simple JSON
+            return ChatCompletionResponse(
+                id=request_id,
+                created=int(time.time()),
+                model="simulator-v1.0.0",
+                choices=[
+                    ChatCompletionChoice(
+                        index=0,
+                        message=ChatMessage(
+                            role="assistant",
+                            content=simulated_content,
+                        ),
+                        finish_reason="stop",
+                    )
+                ],
+                usage=ChatCompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+            )
+
     # Load schema using centralized utility
+    # Enable database fallback to load dynamic agents stored in schemas table
+    # Use async version since we're in an async context (FastAPI endpoint)
+    user_id = temp_context.user_id or settings.test.effective_user_id
     try:
-        agent_schema = load_agent_schema(schema_name)
+        agent_schema = await load_agent_schema_async(
+            schema_name,
+            user_id=user_id,
+        )
     except FileNotFoundError:
         # Fallback to default if specified schema not found
         logger.warning(f"Schema '{schema_name}' not found, falling back to '{DEFAULT_AGENT_SCHEMA}'")
@@ -151,7 +256,7 @@ async def chat_completions(body: ChatCompletionRequest, request: Request):
                 detail=f"Agent schema '{schema_name}' not found and default schema unavailable",
             )
 
-    logger.info(f"Using agent schema: {schema_name}, model: {body.model}")
+    logger.debug(f"Using agent schema: {schema_name}, model: {body.model}")
 
     # Check for audio input
     is_audio = request.headers.get("x-chat-is-audio", "").lower() == "true"
@@ -212,8 +317,35 @@ async def chat_completions(body: ChatCompletionRequest, request: Request):
 
     # 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)
+
         return StreamingResponse(
-            stream_openai_response(agent, prompt, body.model, request_id),
+            stream_openai_response_with_save(
+                agent=agent,
+                prompt=prompt,
+                model=body.model,
+                request_id=request_id,
+                agent_schema=schema_name,
+                session_id=context.session_id,
+                user_id=context.user_id,
+            ),
             media_type="text/event-stream",
             headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
         )
@@ -250,17 +382,21 @@ async def chat_completions(body: ChatCompletionRequest, request: Request):
             "timestamp": datetime.utcnow().isoformat(),
         }
 
-        # Store messages with compression
-        store = SessionMessageStore(user_id=context.user_id or "default")
-
-        await store.store_session_messages(
-            session_id=context.session_id,
-            messages=[user_message, assistant_message],
-            user_id=context.user_id,
-            compress=True,
-        )
+        try:
+            # Store messages with compression
+            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, assistant_message],
+                user_id=context.user_id,
+                compress=True,
+            )
 
-        logger.info(f"Saved conversation to session {context.session_id}")
+            logger.info(f"Saved conversation to session {context.session_id}")
+        except Exception as e:
+            # Log error but don't fail the request - session storage is non-critical
+            logger.error(f"Failed to save session messages: {e}", exc_info=True)
 
     return ChatCompletionResponse(
         id=request_id,

rem/api/routers/chat/models.py

@@ -12,6 +12,8 @@ from typing import Literal
 
 from pydantic import BaseModel, Field
 
+from rem.settings import settings
+
 
 # Request models
 class ChatMessage(BaseModel):
@@ -52,9 +54,11 @@ class ChatCompletionRequest(BaseModel):
     Note: Model is specified in body.model (standard OpenAI field), not headers.
     """
 
-    model: str = Field(
-        default="anthropic:claude-sonnet-4-5-20250929",
-        description="Model to use (standard OpenAI field)",
+    # TODO: default should come from settings.llm.default_model at request time
+    # Using None and resolving in endpoint to avoid import-time settings evaluation
+    model: str | None = Field(
+        default=None,
+        description="Model to use. Defaults to LLM__DEFAULT_MODEL from settings.",
     )
     messages: list[ChatMessage] = Field(description="Chat conversation history")
     temperature: float | None = Field(default=None, ge=0, le=2)