Refactor AGUI event handling and logging

- Removed unnecessary logging statements from the AGUI backend, improving code clarity and reducing log noise.
- Updated frontend components to eliminate redundant console logs, enhancing performance and maintainability.
- Streamlined event processing logic to focus on essential operations, ensuring efficient handling of AGUI events.

These changes enhance the overall efficiency of AGUI event management and improve the clarity of the codebase.

Author: Gkrumbach07

components/backend/websocket/agui.go

@@ -75,7 +75,6 @@ func (r *AGUIRunState) Broadcast(event *types.BaseEvent) {
 		case ch <- event:
 		default:
 			// Channel full, skip
-			log.Printf("AGUI: subscriber channel full, skipping event")
 		}
 	}
 }
@@ -120,14 +119,11 @@ func createInitialAGUIRun(sessionID string) {
 	for _, state := range aguiRuns {
 		if state.SessionID == sessionID {
 			aguiRunsMu.RUnlock()
-			log.Printf("AGUI: Run already exists for session %s, skipping initial run creation", sessionID)
 			return
 		}
 	}
 	aguiRunsMu.RUnlock()
 
-	log.Printf("AGUI: Creating initial run %s for session %s (runner bootstrap)", runID, sessionID)
-
 	runState := &AGUIRunState{
 		ThreadID:     threadID,
 		RunID:        runID,
@@ -156,7 +152,6 @@ func createInitialAGUIRun(sessionID string) {
 // This is the simplified flow - no SessionMessage wrapping, no translation needed
 func RouteAGUIEvent(sessionID string, event map[string]interface{}) {
 	eventType, _ := event["type"].(string)
-	log.Printf("AGUI: RouteAGUIEvent sessionID=%s eventType=%s", sessionID, eventType)
 
 	// Find active run for this session
 	var activeRunState *AGUIRunState
@@ -173,15 +168,13 @@ func RouteAGUIEvent(sessionID string, event map[string]interface{}) {
 	if activeRunState == nil {
 		// Don't create lazy runs for terminal events - they should only apply to existing runs
 		if isTerminalEventType(eventType) {
-			log.Printf("AGUI: Terminal event (%s) for non-existent run, ignoring (session=%s)", eventType, sessionID)
 			go persistAGUIEventMap(sessionID, "", event)
 			return
 		}
 
 		eventRunID, _ := event["runId"].(string)
 		if eventRunID != "" {
 			// Create run lazily from event's runId
-			log.Printf("AGUI: No active run found, creating lazy run for runId=%s session=%s", eventRunID, sessionID)
 			threadID := sessionID
 			activeRunState = &AGUIRunState{
 				ThreadID:     threadID,
@@ -196,7 +189,6 @@ func RouteAGUIEvent(sessionID string, event map[string]interface{}) {
 			aguiRuns[eventRunID] = activeRunState
 			aguiRunsMu.Unlock()
 		} else {
-			log.Printf("AGUI: No active run and no runId in event for session %s, event will only be persisted", sessionID)
 			go persistAGUIEventMap(sessionID, "", event)
 			return
 		}
@@ -209,7 +201,6 @@ func RouteAGUIEvent(sessionID string, event map[string]interface{}) {
 	// Don't use activeRunState.RunID which might be stale
 	if eventRunID, ok := event["runId"].(string); ok && eventRunID != "" {
 		runID = eventRunID
-		log.Printf("AGUI: Using runId from event: %s (activeRun had: %s)", runID, activeRunState.RunID)
 	}
 	if eventThreadID, ok := event["threadId"].(string); ok && eventThreadID != "" {
 		threadID = eventThreadID
@@ -233,7 +224,6 @@ func RouteAGUIEvent(sessionID string, event map[string]interface{}) {
 			select {
 			case ch <- event:
 			default:
-				log.Printf("AGUI: Thread subscriber channel full, skipping event")
 			}
 		}
 	}
@@ -244,7 +234,6 @@ func RouteAGUIEvent(sessionID string, event map[string]interface{}) {
 
 	// Check for terminal events - mark run as complete
 	if isTerminalEventType(eventType) {
-		log.Printf("AGUI: Terminal event detected (%s) for runId=%s sessionID=%s", eventType, runID, sessionID)
 		activeRunState.Status = getTerminalStatusFromType(eventType)
 
 		// Schedule cleanup of run state (no need to compact async - we compact on SSE connect)
@@ -280,11 +269,6 @@ func persistAGUIEventMap(sessionID, runID string, event map[string]interface{})
 		return
 	}
 
-	// Log successful persistence (especially for user messages)
-	eventType, _ := event["type"].(string)
-	if role, ok := event["role"].(string); ok && role == "user" {
-		log.Printf("AGUI: ✓ Persisted USER message event %s (runId=%s)", eventType, runID)
-	}
 }
 
 // isTerminalEventType checks if an event type indicates run completion
@@ -388,11 +372,8 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 		}
 		threadSubscribersMu.Unlock()
 		close(eventCh)
-		log.Printf("AGUI: Thread subscriber disconnected from session %s", sessionName)
 	}()
 
-	log.Printf("AGUI: Thread subscriber connected to session %s", sessionName)
-
 	// OPTION 1: Compact-on-Read Strategy (COMPLETED RUNS ONLY)
 	// Load events from agui-events.jsonl and compact only COMPLETED runs
 	// Active/in-progress runs will be streamed raw
@@ -402,7 +383,6 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 
 	events, err := loadEventsForRun(sessionName, "")
 	if err == nil && len(events) > 0 {
-		log.Printf("AGUI: Loaded %d events from disk for session %s", len(events), sessionName)
 
 		// CRITICAL FIX: Determine which runs are TRULY active by checking event log
 		// A run is only active if NO terminal event exists in the log
@@ -413,7 +393,6 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 
 			if eventRunID != "" && isTerminalEventType(eventType) {
 				runHasTerminalEvent[eventRunID] = true
-				log.Printf("AGUI: Run %s has terminal event %s - will be compacted", eventRunID, eventType)
 			}
 		}
 
@@ -426,12 +405,10 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 				// Only consider active if NO terminal event in log
 				if !runHasTerminalEvent[runID] {
 					activeRunIDs[runID] = true
-					log.Printf("AGUI: Run %s is truly active (no terminal event in log)", runID)
 				} else {
 					// Fix stale memory state
 					if state.Status == "running" {
 						state.Status = "completed"
-						log.Printf("AGUI: Fixed stale state - run %s was 'running' but has terminal event", runID)
 					}
 				}
 			}
@@ -460,15 +437,9 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 			completedEvents = append(completedEvents, event)
 		}
 
-		log.Printf("AGUI: Filtered %d events -> %d completed, %d active (will replay raw)",
-			len(events), len(completedEvents), skippedCount)
-
 		if len(completedEvents) > 0 {
 			// Compact only completed run events
-			log.Printf("AGUI: Compacting %d events from completed runs (excluding %d active runs)",
-				len(completedEvents), len(activeRunIDs))
 			messages := CompactEvents(completedEvents)
-			log.Printf("AGUI: Compacted into %d messages", len(messages))
 
 			// Send single MESSAGES_SNAPSHOT with compacted messages from COMPLETED runs
 			if len(messages) > 0 {
@@ -478,10 +449,7 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 				}
 				writeSSEEvent(c.Writer, snapshot)
 				c.Writer.(http.Flusher).Flush()
-				log.Printf("AGUI: Sent MESSAGES_SNAPSHOT with %d messages from completed runs", len(messages))
 			}
-		} else {
-			log.Printf("AGUI: No completed runs to compact (%d active runs)", len(activeRunIDs))
 		}
 	} else if err != nil {
 		log.Printf("AGUI: Failed to load events: %v", err)
@@ -499,7 +467,6 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 	aguiRunsMu.RUnlock()
 
 	if len(activeRunStates) > 0 {
-		log.Printf("AGUI: Replaying %d active runs with raw events", len(activeRunStates))
 
 		// Load all events once
 		allEvents, err := loadEventsForRun(sessionName, "")
@@ -528,17 +495,13 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 
 				// Replay raw events
 				if len(runEvents) > 0 {
-					log.Printf("AGUI: Replaying %d raw events for active run %s", len(runEvents), activeRunState.RunID)
 					for _, event := range runEvents {
 						writeSSEEvent(c.Writer, event)
 					}
 				}
 			}
 			c.Writer.(http.Flusher).Flush()
-			log.Printf("AGUI: Finished replaying all active runs")
 		}
-	} else {
-		log.Printf("AGUI: No active runs to replay")
 	}
 
 	// Stream events from all future runs with keepalive
@@ -548,7 +511,6 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 	for {
 		select {
 		case <-ctx.Done():
-			log.Printf("AGUI: Thread stream context done for session %s", sessionName)
 			return
 		case <-keepaliveTicker.C:
 			// Send SSE comment to prevent gateway timeout
@@ -560,7 +522,6 @@ func streamThreadEvents(c *gin.Context, projectName, sessionName string) {
 			c.Writer.(http.Flusher).Flush()
 		case event, ok := <-eventCh:
 			if !ok {
-				log.Printf("AGUI: Event channel closed for session %s", sessionName)
 				return
 			}
 			writeSSEEvent(c.Writer, event)
@@ -577,8 +538,6 @@ func HandleAGUIEvents(c *gin.Context) {
 	sessionName := c.Param("sessionName")
 	runID := c.Query("runId")
 
-	log.Printf("AGUI: SSE connection request for session=%s, runId=%s", sessionName, runID)
-
 	// Set SSE headers
 	c.Header("Content-Type", "text/event-stream")
 	c.Header("Cache-Control", "no-cache")
@@ -588,21 +547,18 @@ func HandleAGUIEvents(c *gin.Context) {
 	// If no runId specified, stream the entire THREAD (all runs for this session)
 	// This is the correct AG-UI pattern: client connects once to thread stream
 	if runID == "" {
-		log.Printf("AGUI: Thread-level streaming for session %s", sessionName)
 		streamThreadEvents(c, projectName, sessionName)
 		return
 	}
 
 	// Legacy: specific run streaming (kept for compatibility)
-	log.Printf("AGUI: Run-specific streaming for runId %s", runID)
 
 	var runState *AGUIRunState
 	aguiRunsMu.RLock()
 	runState = aguiRuns[runID]
 	aguiRunsMu.RUnlock()
 
 	if runState == nil {
-		log.Printf("AGUI: Run %s not found, creating implicit run", runID)
 		// Create an implicit run for this connection
 		threadID := sessionName
 		runState = &AGUIRunState{
@@ -649,7 +605,6 @@ func HandleAGUIEvents(c *gin.Context) {
 	for {
 		select {
 		case <-ctx.Done():
-			log.Printf("AGUI: client disconnected from %s/%s", projectName, sessionName)
 			return
 		case event, ok := <-fullEventCh:
 			if !ok {
@@ -684,27 +639,18 @@ func sendInitialSyncEvents(c *gin.Context, runState *AGUIRunState, projectName,
 	events, err := loadEventsForRun(sessionName, runID)
 	if err != nil {
 		log.Printf("AGUI: Failed to load events for %s: %v", sessionName, err)
-	} else {
-		log.Printf("AGUI: Loaded %d events for session %s", len(events), sessionName)
 	}
 
 	if len(events) > 0 {
-		log.Printf("AGUI: Compacting %d events into messages...", len(events))
 		messages := CompactEvents(events)
-		log.Printf("AGUI: Compaction result: %d messages from %d events", len(messages), len(events))
 
 		if len(messages) > 0 {
 			snapshot := &types.MessagesSnapshotEvent{
 				BaseEvent: types.NewBaseEvent(types.EventTypeMessagesSnapshot, threadID, runID),
 				Messages:  messages,
 			}
 			writeSSEEvent(c.Writer, snapshot)
-			log.Printf("AGUI: ✅ Sent MESSAGES_SNAPSHOT with %d messages (compacted from %d events)", len(messages), len(events))
-		} else {
-			log.Printf("AGUI: ⚠️ WARNING - Compaction produced 0 messages from %d events", len(events))
 		}
-	} else {
-		log.Printf("AGUI: No stored events found for session %s - this is normal for new sessions", sessionName)
 	}
 }
 
@@ -792,7 +738,6 @@ func scheduleRunCleanup(runID string, delay time.Duration) {
 		// Only delete if run is no longer active
 		if run.Status != "running" {
 			delete(aguiRuns, runID)
-			log.Printf("AGUI: cleaned up completed run %s", runID)
 		}
 	}
 	aguiRunsMu.Unlock()
@@ -815,7 +760,6 @@ func cleanupInactiveRuns() {
 	for runID, run := range aguiRuns {
 		if run.Status != "running" && run.StartedAt.Before(cutoff) {
 			delete(aguiRuns, runID)
-			log.Printf("AGUI: cleaned up old run %s", runID)
 		}
 	}
 }

components/frontend/src/app/api/projects/[name]/agentic-sessions/[sessionName]/workspace/upload/route.ts

@@ -256,9 +256,6 @@ async function compressImageIfNeeded(
     }
 
     const finalSize = compressed.byteLength;
-    console.log(
-      `Compressed ${contentType} image: ${originalSize} bytes -> ${finalSize} bytes (${Math.round((finalSize / originalSize) * 100)}%)`
-    );
 
     // Convert Node.js Buffer to ArrayBuffer by creating a new ArrayBuffer and copying data
     const arrayBuffer = new ArrayBuffer(finalSize);

components/frontend/src/app/api/projects/[name]/agentic-sessions/route.ts

@@ -31,22 +31,13 @@ export async function POST(
     const body = await request.text();
     const headers = await buildForwardHeadersAsync(request);
 
-    console.log('[API Route] Creating session for project:', name);
-    console.log('[API Route] Auth headers present:', {
-      hasUser: !!headers['X-Forwarded-User'],
-      hasUsername: !!headers['X-Forwarded-Preferred-Username'],
-      hasToken: !!headers['X-Forwarded-Access-Token'],
-      hasEmail: !!headers['X-Forwarded-Email'],
-    });
-    
     const response = await fetch(`${BACKEND_URL}/projects/${encodeURIComponent(name)}/agentic-sessions`, {
       method: 'POST',
       headers,
       body,
     });
 
     const text = await response.text();
-    console.log('[API Route] Backend response status:', response.status);
     if (!response.ok) {
       console.error('[API Route] Backend error:', text);
     }