refactor: update conversation tracking to fetch details from OpenAI API

- Modified `ConversationServiceImpl` to include OpenAI proxy for fetching conversation details.
- Removed title handling from conversation repository and API responses.
- Updated API routes and tests to reflect changes in conversation data structure.
- Added end-to-end tests for conversation tracking and access control.

Author: PierreLeGuen

crates/api/src/main.rs

@@ -74,7 +74,10 @@ async fn main() -> anyhow::Result<()> {
     let proxy_service = Arc::new(proxy_service);
 
     // Initialize conversation service
-    let conversation_service = Arc::new(ConversationServiceImpl::new(conversation_repo));
+    let conversation_service = Arc::new(ConversationServiceImpl::new(
+        conversation_repo,
+        proxy_service.clone(),
+    ));
 
     // Create application state
     let app_state = AppState {

crates/api/src/routes/api.rs

@@ -15,23 +15,17 @@ use std::io::Read;
 
 use crate::middleware::auth::AuthenticatedUser;
 
-#[derive(Serialize, Deserialize)]
-pub struct ConversationResponse {
-    pub id: String,
-    pub title: Option<String>,
-    pub created_at: String,
-    pub updated_at: String,
-}
-
 #[derive(Serialize, Deserialize)]
 pub struct ErrorResponse {
     pub error: String,
 }
 
 /// Create the OpenAI API proxy router
 pub fn create_api_router() -> Router<crate::state::AppState> {
+    // IMPORTANT: Specific routes MUST be in the same Router and registered BEFORE catch-all routes
+    // Axum matches routes in order within a router
     Router::new()
-        // Specific handlers for conversation endpoints (track in DB)
+        // Specific conversation endpoints (handle these before catch-all)
         .route("/v1/conversations", post(create_conversation))
         .route("/v1/conversations", get(list_conversations))
         // Catch-all proxy for all other OpenAI endpoints
@@ -171,7 +165,7 @@ async fn create_conversation(
                 tracing::debug!("Tracking conversation {} in database", conversation_id);
                 if let Err(e) = state
                     .conversation_service
-                    .track_conversation(conversation_id, user.user_id, None)
+                    .track_conversation(conversation_id, user.user_id)
                     .await
                 {
                     tracing::error!(
@@ -234,11 +228,11 @@ async fn create_conversation(
     })
 }
 
-/// List all conversations for the authenticated user (from local DB)
+/// List all conversations for the authenticated user (fetches details from OpenAI client)
 async fn list_conversations(
     State(state): State<crate::state::AppState>,
     Extension(user): Extension<AuthenticatedUser>,
-) -> Result<Json<Vec<ConversationResponse>>, Response> {
+) -> Result<Json<Vec<serde_json::Value>>, Response> {
     tracing::info!("list_conversations called for user_id={}", user.user_id);
 
     let conversations = state
@@ -266,27 +260,7 @@ async fn list_conversations(
         user.user_id
     );
 
-    for conv in &conversations {
-        tracing::debug!(
-            "Conversation: id={}, title={:?}, created={}, updated={}",
-            conv.id,
-            conv.title,
-            conv.created_at,
-            conv.updated_at
-        );
-    }
-
-    Ok(Json(
-        conversations
-            .into_iter()
-            .map(|c| ConversationResponse {
-                id: c.id,
-                title: c.title,
-                created_at: c.created_at.to_rfc3339(),
-                updated_at: c.updated_at.to_rfc3339(),
-            })
-            .collect(),
-    ))
+    Ok(Json(conversations))
 }
 
 /// Generic proxy handler that forwards all requests to OpenAI
@@ -475,7 +449,7 @@ async fn track_conversation_from_request(
 
             state
                 .conversation_service
-                .track_conversation(&conversation_id, user_id, None)
+                .track_conversation(&conversation_id, user_id)
                 .await?;
 
             tracing::info!(

crates/api/tests/README.md

@@ -0,0 +1,145 @@
+# End-to-End API Tests
+
+## Overview
+
+This directory contains comprehensive end-to-end tests for the conversation tracking functionality. The tests verify that the API correctly:
+
+1. Tracks conversation IDs per user in the local database
+2. Fetches conversation details from OpenAI API on demand
+3. Maintains proper access control for conversations
+4. Handles edge cases like empty lists and response-triggered tracking
+
+## Architecture Being Tested
+
+The conversation management system works as follows:
+
+```
+┌─────────────┐         ┌─────────────┐         ┌─────────────┐
+│   Client    │────────>│  Chat API   │────────>│  Database   │
+│             │         │             │         │             │
+│             │         │  - Track    │         │  - User IDs │
+│             │         │    Conv IDs │         │  - Conv IDs │
+└─────────────┘         └─────────────┘         └─────────────┘
+                              │
+                              │ Fetch Details
+                              ▼
+                        ┌─────────────┐
+                        │  OpenAI API │
+                        │             │
+                        │  - Titles   │
+                        │  - Messages │
+                        │  - Metadata │
+                        └─────────────┘
+```
+
+## Test Cases
+
+### 1. `test_conversation_workflow`
+Tests the complete conversation lifecycle:
+- Creates a conversation via OpenAI
+- Adds multiple responses to the conversation
+- Lists conversations and verifies details are fetched from OpenAI
+- Confirms that conversation tracking works end-to-end
+
+### 2. `test_conversation_access_control`
+Verifies access control mechanisms:
+- Creates a conversation for a user
+- Attempts to access it as the owner (should succeed)
+- Validates proper authorization checks
+
+### 3. `test_empty_conversation_list`
+Tests edge case handling:
+- Lists conversations when there may be zero or many
+- Ensures the endpoint handles all cases gracefully
+
+### 4. `test_conversation_tracking_on_response_creation`
+Tests automatic conversation tracking:
+- Creates a conversation
+- Adds a response (which triggers automatic tracking)
+- Verifies the conversation appears in the user's list
+- Confirms details are fetched from OpenAI
+
+## Running the Tests
+
+### Prerequisites
+
+1. **Database**: Ensure PostgreSQL is running with the correct schema
+2. **Environment Variables**: Set up your `.env` file with:
+   ```
+   OPENAI_API_KEY=your_api_key_here
+   DATABASE_HOST=localhost
+   DATABASE_PORT=5432
+   DATABASE_NAME=chat_api
+   DATABASE_USER=postgres
+   DATABASE_PASSWORD=your_password
+   ```
+
+3. **Valid Session Token**: The tests use `SESSION_TOKEN` constant - ensure you have a valid session in the database
+
+### Run All Tests
+
+```bash
+# Run all E2E tests (they make real OpenAI API calls)
+cargo test --test e2e_api_tests -- --ignored --nocapture
+
+# Run a specific test
+cargo test --test e2e_api_tests test_conversation_workflow -- --ignored --nocapture
+```
+
+### Test Output
+
+The tests provide detailed output showing:
+- Step-by-step progress
+- API request/response status codes
+- Conversation IDs and details
+- Success/failure indicators (✓/✗)
+
+Example output:
+```
+=== Test: Conversation Workflow ===
+1. Creating a conversation via OpenAI...
+   Status: 200
+   ✓ Conversation created successfully
+   Conversation ID: conv_abc123...
+
+2. Adding first response to the conversation...
+   Status: 200
+   ✓ First response created successfully
+   Response ID: resp_xyz789...
+
+...
+
+4. Listing conversations (should fetch details from OpenAI)...
+   Found 5 total conversations
+   ✓ Found our conversation in the list!
+      ID: conv_abc123...
+      Created: 2025-11-12T10:30:00Z
+      Updated: 2025-11-12T10:35:00Z
+   ✓ Conversation details fetched from OpenAI
+
+=== Test Complete ===
+✅ Test passed: Created conversation, added responses, and listed conversations with OpenAI details
+```
+
+## Notes
+
+- Tests are marked with `#[ignore]` because they make real API calls to OpenAI
+- Each test is independent and can be run separately
+- Tests use the actual database and OpenAI API (not mocks)
+- The session token must be valid and exist in your database
+
+## Troubleshooting
+
+**Test fails with "Session not found"**
+- Check that `SESSION_TOKEN` constant matches a valid session in your database
+- Ensure the session hasn't expired
+
+**Test fails with "OpenAI API error"**
+- Verify your `OPENAI_API_KEY` is valid
+- Check your OpenAI account has available credits
+
+**Test fails with "Database error"**
+- Ensure PostgreSQL is running
+- Run migrations: `cargo run --bin migrate` or start the API server once
+- Check database connection settings in `.env`
+