fix(lib/httpapi): cap stored errors in EventEmitter to prevent unbounded growth

Previously EventEmitter.errors grew without bound, leaking memory on
long-running servers and sending all historical errors to new SSE
subscribers.

Cap the slice to the most recent 100 errors (maxStoredErrors) so late
subscribers still receive useful context without unbounded memory use.

Author: mafredri

lib/httpapi/events.go

@@ -94,6 +94,9 @@ func convertStatus(status st.ConversationStatus) AgentStatus {
 
 const defaultSubscriptionBufSize uint = 1024
 
+// maxStoredErrors caps the number of errors retained for late subscribers.
+const maxStoredErrors = 100
+
 type EventEmitterOption func(*EventEmitter)
 
 func WithSubscriptionBufSize(size uint) EventEmitterOption {
@@ -224,8 +227,11 @@ func (e *EventEmitter) EmitError(message string, level st.ErrorLevel) {
 		Time:    e.clock.Now(),
 	}
 
-	// Store the error so new subscribers can receive all errors
+	// Store the error so new subscribers can receive recent errors.
 	e.errors = append(e.errors, errorBody)
+	if len(e.errors) > maxStoredErrors {
+		e.errors = e.errors[len(e.errors)-maxStoredErrors:]
+	}
 
 	e.notifyChannels(EventTypeError, errorBody)
 }

lib/httpapi/events_test.go

@@ -99,6 +99,70 @@ func TestEventEmitter(t *testing.T) {
 		}
 	})
 
+	t.Run("error-cap", func(t *testing.T) {
+		emitter := NewEventEmitter(WithSubscriptionBufSize(10))
+
+		for i := range 150 {
+			emitter.EmitError(fmt.Sprintf("error %d", i), st.ErrorLevelError)
+		}
+
+		_, _, stateEvents := emitter.Subscribe()
+
+		var errorEvents []Event
+		for _, ev := range stateEvents {
+			if ev.Type == EventTypeError {
+				errorEvents = append(errorEvents, ev)
+			}
+		}
+
+		assert.Len(t, errorEvents, maxStoredErrors)
+
+		// Errors should be the last 100: "error 50" through "error 149".
+		for i, ev := range errorEvents {
+			body, ok := ev.Payload.(ErrorBody)
+			assert.True(t, ok)
+			assert.Equal(t, fmt.Sprintf("error %d", i+50), body.Message)
+		}
+	})
+
+	t.Run("error-events-in-initial-state", func(t *testing.T) {
+		mockClock := quartz.NewMock(t)
+		fixedTime := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)
+		mockClock.Set(fixedTime)
+
+		emitter := NewEventEmitter(WithClock(mockClock), WithSubscriptionBufSize(10))
+
+		emitter.EmitError("err1", st.ErrorLevelError)
+		mockClock.Set(fixedTime.Add(1 * time.Second))
+		emitter.EmitError("err2", st.ErrorLevelWarning)
+		mockClock.Set(fixedTime.Add(2 * time.Second))
+		emitter.EmitError("err3", st.ErrorLevelError)
+
+		_, _, stateEvents := emitter.Subscribe()
+
+		var errorEvents []Event
+		for _, ev := range stateEvents {
+			if ev.Type == EventTypeError {
+				errorEvents = append(errorEvents, ev)
+			}
+		}
+
+		assert.Len(t, errorEvents, 3)
+
+		expected := []ErrorBody{
+			{Message: "err1", Level: st.ErrorLevelError, Time: fixedTime},
+			{Message: "err2", Level: st.ErrorLevelWarning, Time: fixedTime.Add(1 * time.Second)},
+			{Message: "err3", Level: st.ErrorLevelError, Time: fixedTime.Add(2 * time.Second)},
+		}
+		for i, ev := range errorEvents {
+			body, ok := ev.Payload.(ErrorBody)
+			assert.True(t, ok)
+			assert.Equal(t, expected[i].Message, body.Message)
+			assert.Equal(t, expected[i].Level, body.Level)
+			assert.Equal(t, expected[i].Time, body.Time)
+		}
+	})
+
 	t.Run("clock-injection", func(t *testing.T) {
 		mockClock := quartz.NewMock(t)
 		fixedTime := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)