
-
-
![]()
-
+
+
加载中...
@@ -61,6 +62,7 @@ const preview = (url) => {
}
const removeImg = () => {
nextTick(() => {
+ if (!parentMd.value) return;
const images = parentMd.value.querySelectorAll('img.ai-markdown-img');
if (images) {
images.forEach(async item => {
@@ -184,19 +186,113 @@ onMounted(async () => {
diff --git a/frontend/src/views/chat/index.vue b/frontend/src/views/chat/index.vue
index 04e461ff..9ac03e90 100644
--- a/frontend/src/views/chat/index.vue
+++ b/frontend/src/views/chat/index.vue
@@ -110,13 +110,11 @@ const getmsgList = (data, isScrollType = false, scrollHeight) => {
// Reconstruct agentEventStream from agent_steps stored in database
// This allows the frontend to restore the exact conversation state including all agent reasoning steps
-const reconstructEventStreamFromSteps = (agentSteps) => {
- if (!agentSteps || !Array.isArray(agentSteps) || agentSteps.length === 0) {
- return [];
- }
-
+const reconstructEventStreamFromSteps = (agentSteps, messageContent) => {
const events = [];
+ // Process agent steps if they exist
+ if (agentSteps && Array.isArray(agentSteps) && agentSteps.length > 0) {
agentSteps.forEach((step) => {
// Add thinking event if thought content exists
if (step.thought && step.thought.trim()) {
@@ -148,12 +146,14 @@ const reconstructEventStreamFromSteps = (agentSteps) => {
});
}
});
+ }
- // 添加一个完成标记的 answer 事件,触发折叠逻辑
- if (events.length > 0) {
+ // 总是添加 answer 事件如果有内容(无论是否有 agent_steps)
+ // 这样可以确保最终答案始终被渲染
+ if (messageContent && messageContent.trim()) {
events.push({
type: 'answer',
- content: '', // 空内容,因为最终答案会在 message.content 中
+ content: messageContent,
done: true
});
}
@@ -174,8 +174,8 @@ const handleMsgList = async (data, isScrollType = false, newScrollHeight) => {
if (item.agent_steps && Array.isArray(item.agent_steps) && item.agent_steps.length > 0) {
console.log('[Message Load] Reconstructing agent steps for message:', item.id, 'steps:', item.agent_steps.length);
item.isAgentMode = true;
- item.agentEventStream = reconstructEventStreamFromSteps(item.agent_steps);
- // 隐藏最终答案内容,用户可以通过展开步骤查看完整过程
+ item.agentEventStream = reconstructEventStreamFromSteps(item.agent_steps, item.content);
+ // 隐藏最终答案内容,因为它已经包含在 agentEventStream 的 answer 事件中
item.hideContent = true;
console.log('[Message Load] Reconstructed', item.agentEventStream.length, 'events from agent steps');
}
@@ -530,7 +530,10 @@ const handleAgentChunk = (data) => {
case 'references':
// 知识引用
- if (data.knowledge_references) {
+ if (data.data?.references) {
+ message.knowledge_references = data.data.references;
+ } else if (data.knowledge_references) {
+ // 兼容旧格式
message.knowledge_references = data.knowledge_references;
}
break;
diff --git a/internal/application/service/chat_pipline/chat_completion_stream.go b/internal/application/service/chat_pipline/chat_completion_stream.go
index f8d228e1..045abdcd 100644
--- a/internal/application/service/chat_pipline/chat_completion_stream.go
+++ b/internal/application/service/chat_pipline/chat_completion_stream.go
@@ -3,10 +3,13 @@ package chatpipline
import (
"context"
"errors"
+ "fmt"
+ "github.com/Tencent/WeKnora/internal/event"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/google/uuid"
)
// PluginChatCompletionStream implements streaming chat completion functionality
@@ -49,7 +52,16 @@ func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
logger.Info(ctx, "Preparing chat messages")
chatMessages := prepareMessagesWithHistory(chatManage)
- // Initiate streaming chat model call
+ // EventBus is required for event-driven streaming
+ if chatManage.EventBus == nil {
+ logger.Error(ctx, "EventBus is required but not available")
+ return ErrModelCall.WithError(errors.New("EventBus is required for streaming"))
+ }
+ eventBus := chatManage.EventBus
+
+ logger.Info(ctx, "EventBus detected, enabling event-driven streaming mode")
+
+ // Initiate streaming chat model call with independent context
logger.Info(ctx, "Calling chat stream model")
responseChan, err := chatModel.ChatStream(ctx, chatMessages, opt)
if err != nil {
@@ -62,6 +74,49 @@ func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
}
logger.Info(ctx, "Chat stream initiated successfully")
- chatManage.ResponseChan = responseChan
+
+ // Start goroutine to consume channel and emit events directly
+ go func() {
+ answerID := fmt.Sprintf("%s-answer", uuid.New().String()[:8])
+ var finalContent string
+
+ for response := range responseChan {
+ // Emit event for each answer chunk
+ if response.ResponseType == types.ResponseTypeAnswer {
+ finalContent += response.Content
+ if err := eventBus.Emit(ctx, types.Event{
+ ID: answerID,
+ Type: types.EventType(event.EventAgentFinalAnswer),
+ SessionID: chatManage.SessionID,
+ Data: event.AgentFinalAnswerData{
+ Content: response.Content,
+ Done: response.Done,
+ },
+ }); err != nil {
+ logger.Errorf(ctx, "Failed to emit answer event: %v", err)
+ }
+ }
+ }
+
+ logger.Info(ctx, "Chat stream completed, emitting completion event")
+
+ // Emit completion event when stream finishes
+ // This allows other components to detect stream completion
+ if err := eventBus.Emit(ctx, types.Event{
+ ID: fmt.Sprintf("%s-complete", uuid.New().String()[:8]),
+ Type: types.EventType(event.EventAgentComplete),
+ SessionID: chatManage.SessionID,
+ Data: event.AgentCompleteData{
+ SessionID: chatManage.SessionID,
+ MessageID: chatManage.MessageID,
+ FinalAnswer: finalContent,
+ },
+ }); err != nil {
+ logger.Errorf(ctx, "Failed to emit completion event: %v", err)
+ }
+
+ logger.Info(ctx, "Chat stream completed and completion event emitted")
+ }()
+
return next()
}
diff --git a/internal/application/service/chat_pipline/chat_pipline.go b/internal/application/service/chat_pipline/chat_pipline.go
index c82a7bbd..181757ae 100644
--- a/internal/application/service/chat_pipline/chat_pipline.go
+++ b/internal/application/service/chat_pipline/chat_pipline.go
@@ -138,24 +138,3 @@ func (p *PluginError) WithError(err error) *PluginError {
pp.Err = err
return pp
}
-
-// NewFallbackChan creates a channel with a single fallback response
-func NewFallbackChan(ctx context.Context, fallbackResponse string) <-chan types.StreamResponse {
- fallabackChan := make(chan types.StreamResponse)
- go func() {
- fallabackChan <- NewFallback(ctx, fallbackResponse)
- close(fallabackChan)
- }()
- return fallabackChan
-}
-
-// NewFallback creates a fallback stream response with the given content
-func NewFallback(ctx context.Context, fallbackResponse string) types.StreamResponse {
- requestID := ctx.Value(types.RequestIDContextKey).(string)
- return types.StreamResponse{
- ID: requestID,
- ResponseType: types.ResponseTypeAnswer,
- Content: fallbackResponse,
- Done: true,
- }
-}
diff --git a/internal/application/service/chat_pipline/stream_filter.go b/internal/application/service/chat_pipline/stream_filter.go
index 06d65a5f..73347799 100644
--- a/internal/application/service/chat_pipline/stream_filter.go
+++ b/internal/application/service/chat_pipline/stream_filter.go
@@ -2,10 +2,14 @@ package chatpipline
import (
"context"
+ "errors"
+ "fmt"
"strings"
+ "github.com/Tencent/WeKnora/internal/event"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
+ "github.com/google/uuid"
)
// PluginStreamFilter implements stream filtering functionality for chat pipeline
@@ -28,57 +32,93 @@ func (p *PluginStreamFilter) OnEvent(ctx context.Context,
eventType types.EventType, chatManage *types.ChatManage, next func() *PluginError,
) *PluginError {
logger.Info(ctx, "Starting stream filter")
- logger.Info(ctx, "Creating new stream channel")
- // Create new stream channel and replace the original one
- oldStream := chatManage.ResponseChan
- newStream := make(chan types.StreamResponse)
- chatManage.ResponseChan = newStream
+ // EventBus is required
+ if chatManage.EventBus == nil {
+ logger.Error(ctx, "EventBus is required but not available")
+ return ErrModelCall.WithError(errors.New("EventBus is required for stream filtering"))
+ }
+ eventBus := chatManage.EventBus
- // Initialize response builder and check if no-match prefix filtering is needed
- responseBuilder := &strings.Builder{}
+ // Check if no-match prefix filtering is needed
matchNoMatchBuilderPrefix := chatManage.SummaryConfig.NoMatchPrefix != ""
if matchNoMatchBuilderPrefix {
logger.Infof(ctx, "Using no match prefix filter: %s", chatManage.SummaryConfig.NoMatchPrefix)
+ // Create an event interceptor for prefix filtering
+ return p.filterEventsWithPrefix(ctx, chatManage, eventBus, next)
}
- // Start goroutine to filter the stream
- go func() {
- logger.Info(ctx, "Starting stream filter goroutine")
- for resp := range oldStream {
- // Accumulate answer content
- if resp.ResponseType == types.ResponseTypeAnswer {
- responseBuilder.WriteString(resp.Content)
- }
-
- // Skip filtering if no prefix matching is required
- if !matchNoMatchBuilderPrefix {
- newStream <- resp
- continue
- }
-
- // Check if content matches the no-match prefix
- if !strings.HasPrefix(chatManage.SummaryConfig.NoMatchPrefix, responseBuilder.String()) {
- resp.Content = responseBuilder.String()
- newStream <- resp
- logger.Info(
- ctx, "Content does not match no-match prefix, passing through, content: ",
- responseBuilder.String(),
- )
- matchNoMatchBuilderPrefix = false
- }
- }
-
- // Handle NO_MATCH case when stream ends
- if matchNoMatchBuilderPrefix {
- logger.Info(ctx, "Content matches no-match prefix, using fallback response")
- newStream <- NewFallback(ctx, chatManage.FallbackResponse)
- }
- logger.Info(ctx, "Stream filter completed, closing new stream")
- close(newStream)
- }()
-
- logger.Info(ctx, "Stream filter initialized")
+ // No filtering needed, just pass through
+ logger.Info(ctx, "No prefix filtering required, passing through")
return next()
}
+
+// filterEventsWithPrefix intercepts events, checks for NoMatchPrefix, and re-emits filtered events
+func (p *PluginStreamFilter) filterEventsWithPrefix(
+ ctx context.Context,
+ chatManage *types.ChatManage,
+ originalEventBus types.EventBusInterface,
+ next func() *PluginError,
+) *PluginError {
+ logger.Info(ctx, "Setting up event-based stream filtering with NoMatchPrefix")
+
+ // Create a temporary EventBus to intercept events
+ tempEventBus := event.NewEventBus()
+ chatManage.EventBus = tempEventBus.AsEventBusInterface()
+
+ responseBuilder := &strings.Builder{}
+ matchFound := false
+
+ // Subscribe to answer events from temp bus
+ tempEventBus.On(event.EventAgentFinalAnswer, func(ctx context.Context, evt event.Event) error {
+ data, ok := evt.Data.(event.AgentFinalAnswerData)
+ if !ok {
+ return nil
+ }
+
+ responseBuilder.WriteString(data.Content)
+
+ // Check if content does NOT match the no-match prefix (meaning it's valid content)
+ if !strings.HasPrefix(chatManage.SummaryConfig.NoMatchPrefix, responseBuilder.String()) {
+ logger.Infof(ctx, "Content does not match no-match prefix, emitting valid content: %s", responseBuilder.String())
+
+ // Emit the accumulated content as valid answer
+ originalEventBus.Emit(ctx, types.Event{
+ ID: evt.ID,
+ Type: types.EventType(event.EventAgentFinalAnswer),
+ SessionID: chatManage.SessionID,
+ Data: event.AgentFinalAnswerData{
+ Content: responseBuilder.String(),
+ Done: data.Done,
+ },
+ })
+ matchFound = true
+ }
+
+ return nil
+ })
+
+ // Call next to trigger pipeline stages that will emit to tempEventBus
+ err := next()
+
+ // After pipeline completes, check if we need fallback
+ if !matchFound && responseBuilder.Len() > 0 {
+ logger.Info(ctx, "Content matches no-match prefix, emitting fallback response")
+ fallbackID := fmt.Sprintf("%s-fallback", uuid.New().String()[:8])
+ originalEventBus.Emit(ctx, types.Event{
+ ID: fallbackID,
+ Type: types.EventType(event.EventAgentFinalAnswer),
+ SessionID: chatManage.SessionID,
+ Data: event.AgentFinalAnswerData{
+ Content: chatManage.FallbackResponse,
+ Done: true,
+ },
+ })
+ }
+
+ // Restore original EventBus
+ chatManage.EventBus = originalEventBus
+
+ return err
+}
diff --git a/internal/application/service/chat_pipline/tracing.go b/internal/application/service/chat_pipline/tracing.go
index 8a10e481..76a14080 100644
--- a/internal/application/service/chat_pipline/tracing.go
+++ b/internal/application/service/chat_pipline/tracing.go
@@ -6,6 +6,8 @@ import (
"strings"
"time"
+ "github.com/Tencent/WeKnora/internal/event"
+ "github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/tracing"
"github.com/Tencent/WeKnora/internal/types"
"go.opentelemetry.io/otel/attribute"
@@ -187,28 +189,37 @@ func (p *PluginTracing) ChatCompletionStream(ctx context.Context,
)
responseBuilder := &strings.Builder{}
- oldStream := chatManage.ResponseChan
- newStream := make(chan types.StreamResponse)
- chatManage.ResponseChan = newStream
- go func(ctx context.Context) {
- for resp := range oldStream {
- if resp.ResponseType == types.ResponseTypeAnswer {
- responseBuilder.WriteString(resp.Content)
+ // EventBus is required
+ if chatManage.EventBus == nil {
+ logger.Warn(ctx, "Tracing: EventBus not available, skipping metrics collection")
+ return next()
+ }
+ eventBus := chatManage.EventBus
+
+ // Subscribe to events and collect metrics
+ logger.Info(ctx, "Tracing: Subscribing to answer events for metrics collection")
+
+ eventBus.On(types.EventType(event.EventAgentFinalAnswer), func(ctx context.Context, evt types.Event) error {
+ data, ok := evt.Data.(event.AgentFinalAnswerData)
+ if ok {
+ responseBuilder.WriteString(data.Content)
+
+ // If this is the final chunk, record metrics
+ if data.Done {
+ elapsedMS := time.Since(startTime).Milliseconds()
+ span.SetAttributes(
+ attribute.Bool("chat_completion_success", true),
+ attribute.Int64("response_time_ms", elapsedMS),
+ attribute.String("chat_response", responseBuilder.String()),
+ attribute.Int("final_response_length", responseBuilder.Len()),
+ attribute.Float64("tokens_per_second", float64(responseBuilder.Len())/float64(elapsedMS)*1000),
+ )
+ span.End()
}
- newStream <- resp
}
- elapsedMS := time.Since(startTime).Milliseconds()
- span.SetAttributes(
- attribute.Bool("chat_completion_success", true),
- attribute.Int64("response_time_ms", elapsedMS),
- attribute.String("chat_response", responseBuilder.String()),
- attribute.Int("final_response_length", responseBuilder.Len()),
- attribute.Float64("tokens_per_second", float64(responseBuilder.Len())/float64(elapsedMS)*1000),
- )
- span.End()
- close(newStream)
- }(ctx)
+ return nil
+ })
return next()
}
diff --git a/internal/application/service/session.go b/internal/application/service/session.go
index 784031db..2d064deb 100644
--- a/internal/application/service/session.go
+++ b/internal/application/service/session.go
@@ -15,10 +15,16 @@ import (
"github.com/Tencent/WeKnora/internal/tracing"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
+ "github.com/google/uuid"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
)
+// generateEventID generates a unique event ID with type suffix for better traceability
+func generateEventID(suffix string) string {
+ return fmt.Sprintf("%s-%s", uuid.New().String()[:8], suffix)
+}
+
// sessionService implements the SessionService interface for managing conversation sessions
type sessionService struct {
cfg *config.Config // Application configuration
@@ -393,9 +399,8 @@ func (s *sessionService) GenerateTitleAsync(ctx context.Context, session *types.
}
// KnowledgeQA performs knowledge base question answering with LLM summarization
-func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session, query string, knowledgeBaseIDs []string) (
- []*types.SearchResult, <-chan types.StreamResponse, error,
-) {
+// Events are emitted through eventBus (references, answer chunks, completion)
+func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session, query string, knowledgeBaseIDs []string, assistantMessageID string, eventBus *event.EventBus) error {
logger.Infof(ctx, "Knowledge base question answering parameters, session ID: %s, query: %s", session.ID, query)
// If no knowledge base IDs provided, fall back to session's default
@@ -405,7 +410,7 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
logger.Infof(ctx, "No knowledge base IDs provided, using session default: %s", session.KnowledgeBaseID)
} else {
logger.Warnf(ctx, "Session has no associated knowledge base, session ID: %s", session.ID)
- return nil, nil, errors.New("session has no knowledge base")
+ return errors.New("session has no knowledge base")
}
}
@@ -414,7 +419,7 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
// Determine chat model ID: prioritize Remote models
chatModelID, err := s.selectChatModelID(ctx, session, knowledgeBaseIDs)
if err != nil {
- return nil, nil, err
+ return err
}
// Create chat management object with session settings
@@ -423,6 +428,7 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
Query: query,
RewriteQuery: query,
SessionID: session.ID,
+ MessageID: assistantMessageID, // NEW: For event emission in pipeline
KnowledgeBaseID: knowledgeBaseIDs[0], // For backward compatibility, use first KB ID
KnowledgeBaseIDs: knowledgeBaseIDs, // Multi-KB support
VectorThreshold: session.VectorThreshold,
@@ -447,6 +453,7 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
MaxCompletionTokens: session.SummaryParameters.MaxCompletionTokens,
},
FallbackResponse: session.FallbackResponse,
+ EventBus: eventBus.AsEventBusInterface(), // NEW: For pipeline to emit events directly
}
// Start knowledge QA event processing
@@ -457,11 +464,31 @@ func (s *sessionService) KnowledgeQA(ctx context.Context, session *types.Session
"session_id": session.ID,
"knowledge_base_id": session.KnowledgeBaseID,
})
- return nil, nil, err
+ return err
}
- logger.Info(ctx, "Knowledge base question answering completed")
- return chatManage.MergeResult, chatManage.ResponseChan, nil
+ // Emit references event if we have search results
+ if len(chatManage.MergeResult) > 0 {
+ logger.Infof(ctx, "Emitting references event with %d results", len(chatManage.MergeResult))
+ if err := eventBus.Emit(ctx, event.Event{
+ ID: generateEventID("references"),
+ Type: event.EventAgentReferences,
+ SessionID: session.ID,
+ Data: event.AgentReferencesData{
+ References: chatManage.MergeResult,
+ },
+ }); err != nil {
+ logger.Errorf(ctx, "Failed to emit references event: %v", err)
+ }
+ }
+
+ // Note: Answer events are now emitted directly by chat_completion_stream plugin
+ // Completion event will be emitted when the last answer event has Done=true
+ // We can optionally add a completion watcher here if needed, but for now
+ // the frontend can detect completion from the Done flag
+
+ logger.Info(ctx, "Knowledge base question answering initiated")
+ return nil
}
// selectChatModelID selects the appropriate chat model ID with priority for Remote models
@@ -564,28 +591,43 @@ func (s *sessionService) KnowledgeQAByEvent(ctx context.Context,
)
// Process each event in sequence
- for _, event := range eventList {
- logger.Infof(ctx, "Starting to trigger event: %v", event)
- err := s.eventManager.Trigger(ctx, event, chatManage)
+ for _, eventType := range eventList {
+ logger.Infof(ctx, "Starting to trigger event: %v", eventType)
+ err := s.eventManager.Trigger(ctx, eventType, chatManage)
// Handle case where search returns no results
if err == chatpipline.ErrSearchNothing {
- logger.Warnf(ctx, "Event %v triggered, search result is empty, using fallback response", event)
- chatManage.ResponseChan = chatpipline.NewFallbackChan(ctx, chatManage.FallbackResponse)
+ logger.Warnf(ctx, "Event %v triggered, search result is empty, using fallback response", eventType)
chatManage.ChatResponse = &types.ChatResponse{Content: chatManage.FallbackResponse}
+
+ // Emit fallback response as answer event
+ if chatManage.EventBus != nil {
+ fallbackID := generateEventID("fallback")
+ if err := chatManage.EventBus.Emit(ctx, types.Event{
+ ID: fallbackID,
+ Type: types.EventType(event.EventAgentThought),
+ SessionID: chatManage.SessionID,
+ Data: event.AgentThoughtData{
+ Content: chatManage.FallbackResponse,
+ Done: true,
+ },
+ }); err != nil {
+ logger.Errorf(ctx, "Failed to emit fallback answer event: %v", err)
+ }
+ }
return nil
}
// Handle other errors
if err != nil {
logger.Errorf(ctx, "Event triggering failed, event: %v, error type: %s, description: %s, error: %v",
- event, err.ErrorType, err.Description, err.Err)
+ eventType, err.ErrorType, err.Description, err.Err)
span.RecordError(err.Err)
span.SetStatus(codes.Error, err.Description)
span.SetAttributes(attribute.String("error_type", err.ErrorType))
return err.Err
}
- logger.Infof(ctx, "Event %v triggered successfully", event)
+ logger.Infof(ctx, "Event %v triggered successfully", eventType)
}
logger.Info(ctx, "All events triggered successfully")
@@ -680,9 +722,7 @@ func (s *sessionService) SearchKnowledge(ctx context.Context,
}
// AgentQA performs agent-based question answering with conversation history and streaming support
-func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, query string, assistantMessageID string, eventBus *event.EventBus) (
- []*types.SearchResult, error,
-) {
+func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, query string, assistantMessageID string, eventBus *event.EventBus) error {
sessionID := session.ID
tenantID := ctx.Value(types.TenantIDContextKey).(uint)
logger.Infof(ctx, "Start agent-based question answering, session ID: %s, tenant ID: %d, query: %s", sessionID, tenantID, query)
@@ -696,13 +736,13 @@ func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, qu
// Check if agent is enabled at session level
if session.AgentConfig == nil || !session.AgentConfig.Enabled {
logger.Warnf(ctx, "Agent not enabled for session: %s", sessionID)
- return nil, errors.New("agent not enabled for this session")
+ return errors.New("agent not enabled for this session")
}
// Check if tenant has agent configuration
if tenantInfo.AgentConfig == nil {
logger.Warnf(ctx, "Tenant %d has no agent configuration", tenantInfo.ID)
- return nil, errors.New("tenant has no agent configuration")
+ return errors.New("tenant has no agent configuration")
}
// Create runtime AgentConfig by merging session and tenant configs
@@ -734,12 +774,12 @@ func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, qu
allKBs, err := s.knowledgeBaseService.ListKnowledgeBases(ctx)
if err != nil {
logger.Errorf(ctx, "Failed to list knowledge bases for tenant: %v", err)
- return nil, fmt.Errorf("failed to list knowledge bases: %w", err)
+ return fmt.Errorf("failed to list knowledge bases: %w", err)
}
if len(allKBs) == 0 {
logger.Warnf(ctx, "No knowledge bases available for agent session: %s", sessionID)
- return nil, errors.New("no knowledge bases available for agent")
+ return errors.New("no knowledge bases available for agent")
}
// Extract knowledge base IDs
@@ -764,7 +804,7 @@ func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, qu
summaryModel, err := s.modelService.GetChatModel(ctx, agentConfig.ThinkingModelID)
if err != nil {
logger.Warnf(ctx, "Failed to get chat model: %v", err)
- return nil, fmt.Errorf("failed to get chat model: %w", err)
+ return fmt.Errorf("failed to get chat model: %w", err)
}
// Get or create contextManager for this session
@@ -782,30 +822,27 @@ func (s *sessionService) AgentQA(ctx context.Context, session *types.Session, qu
engine, err := s.agentService.CreateAgentEngine(ctx, agentConfig, eventBus, contextManager, session.ID)
if err != nil {
logger.Errorf(ctx, "Failed to create agent engine: %v", err)
- return nil, err
+ return err
}
// Execute agent with streaming (asynchronously)
// Events will be emitted to EventBus and handled by the Handler layer
logger.Info(ctx, "Executing agent with streaming")
- go func() {
- if _, err := engine.Execute(ctx, sessionID, assistantMessageID, query, llmContext); err != nil {
- logger.Errorf(ctx, "Agent execution failed: %v", err)
- // Emit error event to the EventBus used by this agent
- eventBus.Emit(ctx, event.Event{
- Type: event.EventError,
+ if _, err := engine.Execute(ctx, sessionID, assistantMessageID, query, llmContext); err != nil {
+ logger.Errorf(ctx, "Agent execution failed: %v", err)
+ // Emit error event to the EventBus used by this agent
+ eventBus.Emit(ctx, event.Event{
+ Type: event.EventError,
+ SessionID: sessionID,
+ Data: event.ErrorData{
+ Error: err.Error(),
+ Stage: "agent_execution",
SessionID: sessionID,
- Data: event.ErrorData{
- Error: err.Error(),
- Stage: "agent_execution",
- SessionID: sessionID,
- },
- })
- }
- }()
-
+ },
+ })
+ }
// Return empty - events will be handled by Handler via EventBus subscription
- return nil, nil
+ return nil
}
// getContextManagerForSession creates a context manager for the session based on configuration
diff --git a/internal/event/adapter.go b/internal/event/adapter.go
new file mode 100644
index 00000000..4739fe0a
--- /dev/null
+++ b/internal/event/adapter.go
@@ -0,0 +1,59 @@
+package event
+
+import (
+ "context"
+
+ "github.com/Tencent/WeKnora/internal/types"
+)
+
+// EventBusAdapter adapts *EventBus to types.EventBusInterface
+// This allows EventBus to be used through the interface without circular dependencies
+type EventBusAdapter struct {
+ bus *EventBus
+}
+
+// NewEventBusAdapter creates a new adapter for EventBus
+func NewEventBusAdapter(bus *EventBus) types.EventBusInterface {
+ return &EventBusAdapter{bus: bus}
+}
+
+// On registers an event handler for a specific event type
+func (a *EventBusAdapter) On(eventType types.EventType, handler types.EventHandler) {
+ // Convert types.EventType to event.EventType
+ evtType := EventType(eventType)
+
+ // Convert types.EventHandler to event.EventHandler
+ evtHandler := func(ctx context.Context, evt Event) error {
+ // Convert event.Event to types.Event
+ typesEvt := types.Event{
+ ID: evt.ID,
+ Type: types.EventType(evt.Type),
+ SessionID: evt.SessionID,
+ Data: evt.Data,
+ Metadata: evt.Metadata,
+ RequestID: evt.RequestID,
+ }
+ return handler(ctx, typesEvt)
+ }
+
+ a.bus.On(evtType, evtHandler)
+}
+
+// Emit publishes an event to all registered handlers
+func (a *EventBusAdapter) Emit(ctx context.Context, evt types.Event) error {
+ // Convert types.Event to event.Event
+ eventEvt := Event{
+ ID: evt.ID,
+ Type: EventType(evt.Type),
+ SessionID: evt.SessionID,
+ Data: evt.Data,
+ Metadata: evt.Metadata,
+ RequestID: evt.RequestID,
+ }
+ return a.bus.Emit(ctx, eventEvt)
+}
+
+// AsEventBusInterface converts *EventBus to types.EventBusInterface
+func (eb *EventBus) AsEventBusInterface() types.EventBusInterface {
+ return NewEventBusAdapter(eb)
+}
diff --git a/internal/handler/agent_stream_handler.go b/internal/handler/agent_stream_handler.go
index 55df79fa..5fb2ac26 100644
--- a/internal/handler/agent_stream_handler.go
+++ b/internal/handler/agent_stream_handler.go
@@ -10,14 +10,13 @@ import (
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
- "github.com/gin-gonic/gin"
)
// AgentStreamHandler handles agent events for SSE streaming
// It uses a dedicated EventBus per request to avoid SessionID filtering
+// Events are appended to StreamManager without accumulation
type AgentStreamHandler struct {
ctx context.Context
- ginContext *gin.Context
sessionID string
assistantMessageID string
requestID string
@@ -27,17 +26,15 @@ type AgentStreamHandler struct {
eventBus *event.EventBus
// State tracking
- knowledgeRefs []*types.SearchResult
- finalAnswer string
- accumulatedContent map[string]string // Accumulate content per event ID (thought, answer, reflection)
- eventStartTimes map[string]time.Time // Track start time for duration calculation
- mu sync.Mutex
+ knowledgeRefs []*types.SearchResult
+ finalAnswer string
+ eventStartTimes map[string]time.Time // Track start time for duration calculation
+ mu sync.Mutex
}
// NewAgentStreamHandler creates a new handler for agent SSE streaming
func NewAgentStreamHandler(
ctx context.Context,
- c *gin.Context,
sessionID, assistantMessageID, requestID string,
assistantMessage *types.Message,
streamManager interfaces.StreamManager,
@@ -45,7 +42,6 @@ func NewAgentStreamHandler(
) *AgentStreamHandler {
return &AgentStreamHandler{
ctx: ctx,
- ginContext: c,
sessionID: sessionID,
assistantMessageID: assistantMessageID,
requestID: requestID,
@@ -53,7 +49,6 @@ func NewAgentStreamHandler(
streamManager: streamManager,
eventBus: eventBus,
knowledgeRefs: make([]*types.SearchResult, 0),
- accumulatedContent: make(map[string]string),
eventStartTimes: make(map[string]time.Time),
}
}
@@ -69,7 +64,7 @@ func (h *AgentStreamHandler) Subscribe() {
h.eventBus.On(event.EventAgentFinalAnswer, h.handleFinalAnswer)
h.eventBus.On(event.EventAgentReflection, h.handleReflection)
h.eventBus.On(event.EventError, h.handleError)
- h.eventBus.On(event.EventAgentComplete, h.handleComplete)
+ h.eventBus.On(event.EventSessionTitle, h.handleSessionTitle)
}
// handleThought handles agent thought events
@@ -105,23 +100,18 @@ func (h *AgentStreamHandler) handleThought(ctx context.Context, evt event.Event)
h.mu.Unlock()
- // Send SSE response (real-time incremental)
- response := types.StreamResponse{
- ID: h.requestID,
- ResponseType: types.ResponseTypeThinking,
- Content: data.Content,
- Done: data.Done,
- Data: metadata,
+ // Append this chunk to stream (no accumulation - frontend will accumulate)
+ if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
+ ID: evt.ID,
+ Type: types.ResponseTypeThinking,
+ Content: data.Content, // Just this chunk
+ Done: data.Done,
+ Timestamp: time.Now(),
+ Data: metadata,
+ }); err != nil {
+ logger.GetLogger(h.ctx).Error("Append thought event to stream failed", "error", err)
}
- h.ginContext.SSEvent("message", response)
- h.ginContext.Writer.Flush()
-
- // Accumulate content and replace event in stream (so refresh can see progress)
- h.mu.Lock()
- h.accumulateAndReplaceEventWithData(evt.ID, types.ResponseTypeThinking, data.Content, data.Done, metadata)
- h.mu.Unlock()
-
return nil
}
@@ -137,20 +127,8 @@ func (h *AgentStreamHandler) handleToolCall(ctx context.Context, evt event.Event
"arguments": data.Arguments,
}
- // Send SSE response
- response := types.StreamResponse{
- ID: h.requestID,
- ResponseType: types.ResponseTypeToolCall,
- Content: fmt.Sprintf("Calling tool: %s", data.ToolName),
- Done: false,
- Data: metadata,
- }
-
- h.ginContext.SSEvent("message", response)
- h.ginContext.Writer.Flush()
-
- // Push event to stream for replay on refresh
- if err := h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
+ // Append event to stream
+ if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
ID: evt.ID,
Type: types.ResponseTypeToolCall,
Content: fmt.Sprintf("Calling tool: %s", data.ToolName),
@@ -158,7 +136,7 @@ func (h *AgentStreamHandler) handleToolCall(ctx context.Context, evt event.Event
Timestamp: time.Now(),
Data: metadata,
}); err != nil {
- logger.GetLogger(h.ctx).Error("Push tool call event to stream failed", "error", err)
+ logger.GetLogger(h.ctx).Error("Append tool call event to stream failed", "error", err)
}
return nil
@@ -197,19 +175,8 @@ func (h *AgentStreamHandler) handleToolResult(ctx context.Context, evt event.Eve
}
}
- response := types.StreamResponse{
- ID: h.requestID,
- ResponseType: responseType,
- Content: content,
- Done: false,
- Data: metadata,
- }
-
- h.ginContext.SSEvent("message", response)
- h.ginContext.Writer.Flush()
-
- // Push event to stream for replay on refresh
- if err := h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
+ // Append event to stream
+ if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
ID: evt.ID,
Type: responseType,
Content: content,
@@ -217,7 +184,7 @@ func (h *AgentStreamHandler) handleToolResult(ctx context.Context, evt event.Eve
Timestamp: time.Now(),
Data: metadata,
}); err != nil {
- logger.GetLogger(h.ctx).Error("Push tool result event to stream failed", "error", err)
+ logger.GetLogger(h.ctx).Error("Append tool result event to stream failed", "error", err)
}
return nil
@@ -271,26 +238,8 @@ func (h *AgentStreamHandler) handleReferences(ctx context.Context, evt event.Eve
// Update assistant message references
h.assistantMessage.KnowledgeReferences = h.knowledgeRefs
- // Send SSE response
- response := types.StreamResponse{
- ID: h.requestID,
- ResponseType: types.ResponseTypeReferences,
- KnowledgeReferences: h.knowledgeRefs,
- Done: false,
- }
-
- h.ginContext.SSEvent("message", response)
- h.ginContext.Writer.Flush()
-
- // Update stream references
- if err := h.streamManager.UpdateReferences(
- h.ctx, h.sessionID, h.assistantMessageID, h.knowledgeRefs,
- ); err != nil {
- logger.GetLogger(h.ctx).Error("Update stream references failed", "error", err)
- }
-
- // Push event to stream for replay on refresh
- if err := h.streamManager.PushEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
+ // Append references event to stream
+ if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
ID: evt.ID,
Type: types.ResponseTypeReferences,
Content: "",
@@ -300,7 +249,7 @@ func (h *AgentStreamHandler) handleReferences(ctx context.Context, evt event.Eve
"references": h.knowledgeRefs,
},
}); err != nil {
- logger.GetLogger(h.ctx).Error("Push references event to stream failed", "error", err)
+ logger.GetLogger(h.ctx).Error("Append references event to stream failed", "error", err)
}
return nil
@@ -314,26 +263,21 @@ func (h *AgentStreamHandler) handleFinalAnswer(ctx context.Context, evt event.Ev
}
h.mu.Lock()
-
- // Accumulate final answer (this persists and won't be reset)
+ // Accumulate final answer locally for assistant message (database)
h.finalAnswer += data.Content
- h.assistantMessage.Content = h.finalAnswer
-
- // Send SSE response (real-time incremental)
- response := types.StreamResponse{
- ID: h.requestID,
- ResponseType: types.ResponseTypeAnswer,
- Content: data.Content,
- Done: data.Done,
- }
-
- h.ginContext.SSEvent("message", response)
- h.ginContext.Writer.Flush()
-
- // Replace answer event in stream (so refresh can see progress)
- h.accumulateAndReplaceEvent(evt.ID, types.ResponseTypeAnswer, data.Content, data.Done)
h.mu.Unlock()
+ // Append this chunk to stream (frontend will accumulate by event ID)
+ if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
+ ID: evt.ID,
+ Type: types.ResponseTypeAnswer,
+ Content: data.Content, // Just this chunk
+ Done: data.Done,
+ Timestamp: time.Now(),
+ }); err != nil {
+ logger.GetLogger(h.ctx).Error("Append answer event to stream failed", "error", err)
+ }
+
return nil
}
@@ -344,22 +288,17 @@ func (h *AgentStreamHandler) handleReflection(ctx context.Context, evt event.Eve
return nil
}
- // Send reflection as SSE (real-time incremental)
- response := types.StreamResponse{
- ID: h.requestID,
- ResponseType: "reflection", // Special type for reflection
- Content: data.Content,
- Done: data.Done,
+ // Append this chunk to stream (frontend will accumulate by event ID)
+ if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
+ ID: evt.ID,
+ Type: types.ResponseTypeReflection,
+ Content: data.Content, // Just this chunk
+ Done: data.Done,
+ Timestamp: time.Now(),
+ }); err != nil {
+ logger.GetLogger(h.ctx).Error("Append reflection event to stream failed", "error", err)
}
- h.ginContext.SSEvent("message", response)
- h.ginContext.Writer.Flush()
-
- // Accumulate reflection per tool call and replace event in stream
- h.mu.Lock()
- h.accumulateAndReplaceEvent(evt.ID, types.ResponseTypeReflection, data.Content, data.Done)
- h.mu.Unlock()
-
return nil
}
@@ -370,97 +309,52 @@ func (h *AgentStreamHandler) handleError(ctx context.Context, evt event.Event) e
return nil
}
- response := types.StreamResponse{
- ID: h.requestID,
- ResponseType: types.ResponseTypeError,
- Content: data.Error,
- Done: true,
+ // Build error metadata
+ metadata := map[string]interface{}{
+ "stage": data.Stage,
+ "error": data.Error,
}
- h.ginContext.SSEvent("message", response)
- h.ginContext.Writer.Flush()
+ // Append error event to stream
+ if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
+ ID: evt.ID,
+ Type: types.ResponseTypeError,
+ Content: data.Error,
+ Done: true,
+ Timestamp: time.Now(),
+ Data: metadata,
+ }); err != nil {
+ logger.GetLogger(h.ctx).Error("Append error event to stream failed", "error", err)
+ }
return nil
}
-// handleComplete handles agent complete events
-func (h *AgentStreamHandler) handleComplete(ctx context.Context, evt event.Event) error {
- data, ok := evt.Data.(event.AgentCompleteData)
+// handleSessionTitle handles session title update events
+func (h *AgentStreamHandler) handleSessionTitle(ctx context.Context, evt event.Event) error {
+ data, ok := evt.Data.(event.SessionTitleData)
if !ok {
return nil
}
- h.mu.Lock()
- defer h.mu.Unlock()
-
- // Update assistant message with final data
- if data.MessageID == h.assistantMessageID {
- h.assistantMessage.Content = data.FinalAnswer
- h.assistantMessage.IsCompleted = true
-
- // Update knowledge references if provided
- if len(data.KnowledgeRefs) > 0 {
- knowledgeRefs := make([]*types.SearchResult, 0, len(data.KnowledgeRefs))
- for _, ref := range data.KnowledgeRefs {
- if sr, ok := ref.(*types.SearchResult); ok {
- knowledgeRefs = append(knowledgeRefs, sr)
- }
- }
- h.assistantMessage.KnowledgeReferences = knowledgeRefs
- }
-
- // Update agent steps if provided
- if data.AgentSteps != nil {
- if steps, ok := data.AgentSteps.([]types.AgentStep); ok {
- h.assistantMessage.AgentSteps = steps
- }
- }
- }
-
- // Complete stream
- if err := h.streamManager.CompleteStream(h.ctx, h.sessionID, h.assistantMessageID); err != nil {
- logger.GetLogger(h.ctx).Error("Complete stream failed", "error", err)
+ // Append title event to stream
+ if err := h.streamManager.AppendEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
+ ID: evt.ID,
+ Type: types.ResponseTypeSessionTitle,
+ Content: data.Title,
+ Done: true,
+ Timestamp: time.Now(),
+ Data: map[string]interface{}{
+ "session_id": data.SessionID,
+ "title": data.Title,
+ },
+ }); err != nil {
+ logger.GetLogger(h.ctx).Error("Append session title event to stream failed", "error", err)
}
return nil
}
-// accumulateAndReplaceEvent accumulates content per event ID and replaces the event in stream
-// This is a common pattern for thought, answer, and reflection events
-func (h *AgentStreamHandler) accumulateAndReplaceEvent(
- evtID string,
- evtType types.ResponseType,
- content string,
- done bool,
-) {
- h.accumulateAndReplaceEventWithData(evtID, evtType, content, done, nil)
-}
-
-// accumulateAndReplaceEventWithData accumulates content and replaces event with metadata
-func (h *AgentStreamHandler) accumulateAndReplaceEventWithData(
- evtID string,
- evtType types.ResponseType,
- content string,
- done bool,
- data map[string]interface{},
-) {
- h.accumulatedContent[evtID] += content
- if err := h.streamManager.ReplaceEvent(h.ctx, h.sessionID, h.assistantMessageID, interfaces.StreamEvent{
- ID: evtID,
- Type: evtType,
- Content: h.accumulatedContent[evtID],
- Done: done,
- Timestamp: time.Now(),
- Data: data,
- }); err != nil {
- logger.GetLogger(h.ctx).Error(fmt.Sprintf("Replace %s event in stream failed", evtType), "error", err)
- }
- // Clean up when done
- if done {
- delete(h.accumulatedContent, evtID)
- }
-}
-
// Helper functions
func getString(m map[string]interface{}, key string) string {
if val, ok := m[key].(string); ok {
diff --git a/internal/handler/session.go b/internal/handler/session.go
index 5ffd214a..eb48adc6 100644
--- a/internal/handler/session.go
+++ b/internal/handler/session.go
@@ -3,7 +3,6 @@ package handler
import (
"context"
"fmt"
- "io"
"net/http"
"time"
@@ -14,7 +13,6 @@ import (
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
- "github.com/google/uuid"
)
// SessionHandler handles all HTTP requests related to conversation sessions
@@ -571,154 +569,141 @@ func (h *SessionHandler) ContinueStream(c *gin.Context) {
return
}
- // Get stream information
- streamInfo, err := h.streamManager.GetStream(ctx, sessionID, messageID)
+ // Get initial events from stream (offset 0)
+ events, currentOffset, err := h.streamManager.GetEvents(ctx, sessionID, messageID, 0)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError(fmt.Sprintf("Failed to get stream data: %s", err.Error())))
return
}
- if streamInfo == nil {
- logger.Warnf(ctx, "Active stream not found, session ID: %s, message ID: %s", sessionID, messageID)
+ if len(events) == 0 {
+ logger.Warnf(ctx, "No events found in stream, session ID: %s, message ID: %s", sessionID, messageID)
c.JSON(http.StatusNotFound, gin.H{
"success": false,
- "error": "Active stream not found",
- })
- return
- }
-
- // If stream is already completed, return the full message
- if streamInfo.IsCompleted {
- logger.Infof(
- ctx, "Stream already completed, returning directly, session ID: %s, message ID: %s", sessionID, messageID,
- )
- c.JSON(http.StatusOK, gin.H{
- "id": message.ID,
- "role": message.Role,
- "content": message.Content,
- "created_at": message.CreatedAt,
- "done": true,
+ "error": "No stream events found",
})
return
}
logger.Infof(
- ctx, "Preparing to set SSE headers and send stream data, session ID: %s, message ID: %s", sessionID, messageID,
+ ctx, "Preparing to replay %d events and continue streaming, session ID: %s, message ID: %s",
+ len(events), sessionID, messageID,
)
- // Send knowledge references first if available
- if len(streamInfo.KnowledgeReferences) > 0 {
- logger.Debug(ctx, "Sending knowledge references")
- c.SSEvent("message", &types.StreamResponse{
- ID: message.RequestID,
- ResponseType: types.ResponseTypeReferences,
- Done: false,
- KnowledgeReferences: streamInfo.KnowledgeReferences,
- })
+ // Set headers for SSE
+ c.Header("Content-Type", "text/event-stream")
+ c.Header("Cache-Control", "no-cache")
+ c.Header("Connection", "keep-alive")
+ c.Header("X-Accel-Buffering", "no")
+
+ // Check if stream is already completed
+ streamCompleted := false
+ for _, evt := range events {
+ if evt.Type == "complete" {
+ streamCompleted = true
+ break
+ }
}
// Replay existing events
- if len(streamInfo.Events) > 0 {
- logger.Debugf(ctx, "Replaying %d existing events", len(streamInfo.Events))
- for _, evt := range streamInfo.Events {
- c.SSEvent("message", &types.StreamResponse{
- ID: message.RequestID,
- ResponseType: evt.Type,
- Content: evt.Content,
- Done: evt.Done,
- Data: evt.Data,
- })
+ logger.Debugf(ctx, "Replaying %d existing events", len(events))
+ for _, evt := range events {
+ response := &types.StreamResponse{
+ ID: message.RequestID,
+ ResponseType: evt.Type,
+ Content: evt.Content,
+ Done: evt.Done,
+ Data: evt.Data,
}
- }
- // Create channels to monitor event updates
- eventIndexCh := make(chan int, 10)
- doneCh := make(chan bool, 1)
-
- logger.Debug(ctx, "Starting event update monitoring")
-
- // Start a goroutine to monitor for new events
- go func() {
- ticker := time.NewTicker(100 * time.Millisecond)
- defer ticker.Stop()
-
- currentEventCount := len(streamInfo.Events)
-
- for {
- select {
- case <-ticker.C:
- latestStreamInfo, err := h.streamManager.GetStream(ctx, sessionID, messageID)
- if err != nil {
- logger.Errorf(ctx, "Failed to get stream data: %v", err)
- doneCh <- true
- return
- }
-
- if latestStreamInfo == nil {
- logger.Debug(ctx, "Stream no longer exists")
- doneCh <- true
- return
- }
-
- if latestStreamInfo.IsCompleted {
- logger.Debug(ctx, "Stream completed")
- doneCh <- true
- return
- }
-
- // Check for new events
- if len(latestStreamInfo.Events) > currentEventCount {
- eventIndexCh <- currentEventCount
- currentEventCount = len(latestStreamInfo.Events)
- logger.Debugf(ctx, "Detected %d new events", len(latestStreamInfo.Events)-currentEventCount)
- }
-
- case <-c.Request.Context().Done():
- logger.Debug(ctx, "Client connection closed")
- return
+ // Special handling for references event
+ if evt.Type == types.ResponseTypeReferences {
+ if refs, ok := evt.Data["references"].(types.References); ok {
+ response.KnowledgeReferences = refs
}
}
- }()
- logger.Info(ctx, "Starting stream response")
+ c.SSEvent("message", response)
+ c.Writer.Flush()
+ }
- // Stream new events to client
- c.Stream(func(w io.Writer) bool {
+ // If stream is already completed, send final event and return
+ if streamCompleted {
+ logger.Infof(ctx, "Stream already completed, session ID: %s, message ID: %s", sessionID, messageID)
+ c.SSEvent("message", &types.StreamResponse{
+ ID: message.RequestID,
+ ResponseType: types.ResponseTypeAnswer,
+ Content: "",
+ Done: true,
+ })
+ c.Writer.Flush()
+ return
+ }
+
+ // Continue polling for new events
+ logger.Debug(ctx, "Starting event update monitoring")
+ ticker := time.NewTicker(100 * time.Millisecond)
+ defer ticker.Stop()
+
+ for {
select {
case <-c.Request.Context().Done():
logger.Debug(ctx, "Client connection closed")
- return false
+ return
- case <-doneCh:
- logger.Debug(ctx, "Stream completed, sending completion notification")
- c.SSEvent("message", &types.StreamResponse{
- ID: message.RequestID,
- ResponseType: types.ResponseTypeAnswer,
- Content: "",
- Done: true,
- })
- return false
-
- case startIdx := <-eventIndexCh:
- // Send new events
- latestStreamInfo, err := h.streamManager.GetStream(ctx, sessionID, messageID)
- if err == nil && latestStreamInfo != nil {
- for i := startIdx; i < len(latestStreamInfo.Events); i++ {
- evt := latestStreamInfo.Events[i]
- logger.Debugf(ctx, "Sending new event: %s", evt.Type)
- c.SSEvent("message", &types.StreamResponse{
- ID: message.RequestID,
- ResponseType: evt.Type,
- Content: evt.Content,
- Done: evt.Done,
- Data: evt.Data,
- })
- }
+ case <-ticker.C:
+ // Get new events from current offset
+ newEvents, newOffset, err := h.streamManager.GetEvents(ctx, sessionID, messageID, currentOffset)
+ if err != nil {
+ logger.Errorf(ctx, "Failed to get new events: %v", err)
+ return
+ }
+
+ // Send new events
+ streamCompletedNow := false
+ for _, evt := range newEvents {
+ response := &types.StreamResponse{
+ ID: message.RequestID,
+ ResponseType: evt.Type,
+ Content: evt.Content,
+ Done: evt.Done,
+ Data: evt.Data,
+ }
+
+ // Special handling for references event
+ if evt.Type == types.ResponseTypeReferences {
+ if refs, ok := evt.Data["references"].(types.References); ok {
+ response.KnowledgeReferences = refs
+ }
+ }
+
+ // Check for completion event
+ if evt.Type == "complete" {
+ streamCompletedNow = true
+ }
+
+ c.SSEvent("message", response)
+ c.Writer.Flush()
+ }
+
+ // Update offset
+ currentOffset = newOffset
+
+ // If stream completed, send final event and exit
+ if streamCompletedNow {
+ logger.Infof(ctx, "Stream completed, session ID: %s, message ID: %s", sessionID, messageID)
+ c.SSEvent("message", &types.StreamResponse{
+ ID: message.RequestID,
+ ResponseType: types.ResponseTypeAnswer,
+ Content: "",
+ Done: true,
+ })
+ c.Writer.Flush()
+ return
}
- return true
}
- })
+ }
}
// KnowledgeQA handles knowledge base question answering requests with LLM summarization
@@ -750,7 +735,6 @@ func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
RequestID: c.GetString(types.RequestIDContextKey.String()),
IsCompleted: false,
}
- defer h.completeAssistantMessage(ctx, assistantMessage)
// Validate query content
if request.Query == "" {
@@ -761,50 +745,52 @@ func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
logger.Infof(ctx, "Knowledge QA request, session ID: %s, query: %s", sessionID, request.Query)
- // Get request ID for title generation
- requestID := c.GetString(types.RequestIDContextKey.String())
-
- // Get session to check if title needs to be generated
+ // Get session to prepare knowledge base IDs
session, err := h.sessionService.GetSession(ctx, sessionID)
if err != nil {
logger.Errorf(ctx, "Failed to get session, session ID: %s, error: %v", sessionID, err)
- // Continue anyway - this is not critical
- } else {
- // Start async title generation if session has no title
- if session.Title == "" {
- logger.Infof(ctx, "Session has no title, starting async title generation, session ID: %s", sessionID)
- // Use a simple event bus for title generation
- titleEventBus := event.NewEventBus()
- // Subscribe to title events and push to SSE
- titleEventBus.On(event.EventSessionTitle, func(ctx context.Context, evt event.Event) error {
- data, ok := evt.Data.(event.SessionTitleData)
- if !ok {
- return nil
- }
- // Send title update via SSE
- c.SSEvent("message", &types.StreamResponse{
- ID: requestID,
- ResponseType: types.ResponseTypeSessionTitle,
- Content: data.Title,
- Done: true,
- Data: map[string]interface{}{
- "session_id": data.SessionID,
- "title": data.Title,
- },
- })
- c.Writer.Flush()
- return nil
- })
- h.sessionService.GenerateTitleAsync(ctx, session, request.Query, titleEventBus)
- }
+ c.Error(errors.NewInternalServerError(err.Error()))
+ return
}
+ // Prepare knowledge base IDs
+ knowledgeBaseIDs := request.KnowledgeBaseIDs
+ if len(knowledgeBaseIDs) == 0 && session.KnowledgeBaseID != "" {
+ knowledgeBaseIDs = []string{session.KnowledgeBaseID}
+ logger.Infof(ctx, "No knowledge base IDs in request, using session default: %s", session.KnowledgeBaseID)
+ }
+
+ // Use shared function to handle KnowledgeQA request
+ h.handleKnowledgeQARequest(ctx, c, session, request.Query, knowledgeBaseIDs, assistantMessage, true)
+}
+
+// completeAssistantMessage marks an assistant message as complete and updates it
+func (h *SessionHandler) completeAssistantMessage(ctx context.Context, assistantMessage *types.Message) {
+ assistantMessage.UpdatedAt = time.Now()
+ assistantMessage.IsCompleted = true
+ _ = h.messageService.UpdateMessage(ctx, assistantMessage)
+}
+
+// handleKnowledgeQARequest handles a KnowledgeQA request with the given parameters
+// This is a shared function used by both KnowledgeQA endpoint and AgentQA fallback
+func (h *SessionHandler) handleKnowledgeQARequest(
+ ctx context.Context,
+ c *gin.Context,
+ session *types.Session,
+ query string,
+ knowledgeBaseIDs []string,
+ assistantMessage *types.Message,
+ generateTitle bool, // Whether to generate title if session has no title
+) {
+ sessionID := session.ID
+ requestID := c.GetString(types.RequestIDContextKey.String())
+
// Create user message
if _, err := h.messageService.CreateMessage(ctx, &types.Message{
SessionID: sessionID,
Role: "user",
- Content: request.Query,
- RequestID: c.GetString(types.RequestIDContextKey.String()),
+ Content: query,
+ RequestID: requestID,
CreatedAt: time.Now(),
IsCompleted: true,
}); err != nil {
@@ -818,14 +804,6 @@ func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
c.Error(errors.NewInternalServerError(err.Error()))
return
}
- logger.Infof(ctx, "Calling knowledge QA service, session ID: %s", sessionID)
-
- // Prepare knowledge base IDs
- knowledgeBaseIDs := request.KnowledgeBaseIDs
- if len(knowledgeBaseIDs) == 0 && session.KnowledgeBaseID != "" {
- knowledgeBaseIDs = []string{session.KnowledgeBaseID}
- logger.Infof(ctx, "No knowledge base IDs in request, using session default: %s", session.KnowledgeBaseID)
- }
// Validate knowledge bases
if len(knowledgeBaseIDs) == 0 {
@@ -836,89 +814,76 @@ func (h *SessionHandler) KnowledgeQA(c *gin.Context) {
logger.Infof(ctx, "Using knowledge bases: %v", knowledgeBaseIDs)
- // Call service to perform knowledge QA
- searchResults, respCh, err := h.sessionService.KnowledgeQA(ctx, session, request.Query, knowledgeBaseIDs)
- if err != nil {
- logger.ErrorWithFields(ctx, err, nil)
- c.Error(errors.NewInternalServerError(err.Error()))
- return
- }
- assistantMessage.KnowledgeReferences = searchResults
-
- // Register new stream with stream manager
- if err := h.streamManager.RegisterStream(ctx, sessionID, assistantMessage.ID, request.Query); err != nil {
- logger.GetLogger(ctx).Error("Register stream failed", "error", err)
- }
-
// Set headers for SSE
c.Header("Content-Type", "text/event-stream")
c.Header("Cache-Control", "no-cache")
c.Header("Connection", "keep-alive")
c.Header("X-Accel-Buffering", "no")
- // Send knowledge references if available
- if len(searchResults) > 0 {
- logger.Debugf(ctx, "Sending reference content, total %d", len(searchResults))
- c.SSEvent("message", &types.StreamResponse{
- ID: requestID,
- ResponseType: types.ResponseTypeReferences,
- KnowledgeReferences: searchResults,
- })
- c.Writer.Flush()
- } else {
- logger.Debug(ctx, "No reference content to send")
+ // Create dedicated EventBus for this request
+ eventBus := event.NewEventBus()
+ asyncCtx := logger.CloneContext(ctx)
+
+ // Create stream handler with dedicated EventBus
+ streamHandler := NewAgentStreamHandler(
+ asyncCtx, sessionID, assistantMessage.ID, requestID,
+ assistantMessage, h.streamManager, eventBus,
+ )
+
+ // Subscribe to events on the dedicated EventBus
+ streamHandler.Subscribe()
+
+ // Generate title if needed
+ if generateTitle && session.Title == "" {
+ logger.Infof(ctx, "Session has no title, starting async title generation, session ID: %s", sessionID)
+ h.sessionService.GenerateTitleAsync(asyncCtx, session, query, eventBus)
}
- // Process streamed response
- func() {
+ eventBus.On(event.EventAgentFinalAnswer, func(ctx context.Context, evt event.Event) error {
+ data, ok := evt.Data.(event.AgentFinalAnswerData)
+ if !ok {
+ return nil
+ }
+ assistantMessage.Content += data.Content
+ if data.Done {
+ logger.Infof(asyncCtx, "Knowledge QA service completed for session: %s", sessionID)
+ h.completeAssistantMessage(asyncCtx, assistantMessage)
+ return nil
+ }
+ return nil
+ })
+
+ // Call service to perform knowledge QA (async, emits events)
+ go func() {
defer func() {
- // Mark stream as completed when done
- if err := h.streamManager.CompleteStream(ctx, sessionID, assistantMessage.ID); err != nil {
- logger.GetLogger(ctx).Error("Complete stream failed", "error", err)
+ if r := recover(); r != nil {
+ logger.ErrorWithFields(asyncCtx, errors.NewInternalServerError("Knowledge QA service panicked"), nil)
}
}()
- for response := range respCh {
- response.ID = requestID
- c.SSEvent("message", response)
- c.Writer.Flush()
- if response.ResponseType == types.ResponseTypeAnswer {
- assistantMessage.Content += response.Content
- // Push event to stream for replay on refresh
- if err := h.streamManager.PushEvent(
- ctx, sessionID, assistantMessage.ID, interfaces.StreamEvent{
- ID: uuid.New().String(),
- Type: response.ResponseType,
- Content: response.Content,
- Done: response.Done,
- Timestamp: time.Now(),
- },
- ); err != nil {
- logger.GetLogger(ctx).Error("Push answer event to stream failed", "error", err)
- }
- }
- if response.ResponseType == types.ResponseTypeReferences {
- // Update references
- if err := h.streamManager.UpdateReferences(
- ctx, sessionID, assistantMessage.ID, searchResults,
- ); err != nil {
- logger.GetLogger(ctx).Error("Update stream references failed", "error", err)
- }
- }
+ err := h.sessionService.KnowledgeQA(asyncCtx, session, query, knowledgeBaseIDs, assistantMessage.ID, eventBus)
+ if err != nil {
+ logger.ErrorWithFields(asyncCtx, err, nil)
+ // Emit error event to dedicated EventBus
+ eventBus.Emit(asyncCtx, event.Event{
+ Type: event.EventError,
+ SessionID: sessionID,
+ Data: event.ErrorData{
+ Error: err.Error(),
+ Stage: "knowledge_qa_execution",
+ SessionID: sessionID,
+ },
+ })
+ return
}
}()
-}
-// completeAssistantMessage marks an assistant message as complete and updates it
-func (h *SessionHandler) completeAssistantMessage(ctx context.Context, assistantMessage *types.Message) {
- assistantMessage.UpdatedAt = time.Now()
- assistantMessage.IsCompleted = true
- _ = h.messageService.UpdateMessage(ctx, assistantMessage)
+ // Handle events for SSE (blocking until connection is done)
+ h.handleAgentEventsForSSEWithHandler(ctx, c, sessionID, assistantMessage.ID, requestID)
}
// AgentQA handles agent-based question answering with conversation history and streaming
func (h *SessionHandler) AgentQA(c *gin.Context) {
ctx := logger.CloneContext(c.Request.Context())
-
logger.Info(ctx, "Start processing agent QA request")
// Get session ID from URL parameter
@@ -937,15 +902,6 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
return
}
- // Create assistant message
- assistantMessage := &types.Message{
- SessionID: sessionID,
- Role: "assistant",
- RequestID: c.GetString(types.RequestIDContextKey.String()),
- IsCompleted: false,
- }
- defer h.completeAssistantMessage(ctx, assistantMessage)
-
// Validate query content
if request.Query == "" {
logger.Error(ctx, "Query content is empty")
@@ -963,6 +919,14 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
return
}
+ // Create assistant message
+ assistantMessage := &types.Message{
+ SessionID: sessionID,
+ Role: "assistant",
+ RequestID: c.GetString(types.RequestIDContextKey.String()),
+ IsCompleted: false,
+ }
+
// Initialize AgentConfig if it doesn't exist
if session.AgentConfig == nil {
session.AgentConfig = &types.SessionAgentConfig{}
@@ -1051,86 +1015,8 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
logger.Infof(ctx, "Delegating to KnowledgeQA with knowledge bases: %v", knowledgeBaseIDs)
- // Create user message
- requestID := c.GetString(types.RequestIDContextKey.String())
- if _, err := h.messageService.CreateMessage(ctx, &types.Message{
- SessionID: sessionID,
- Role: "user",
- Content: request.Query,
- RequestID: requestID,
- CreatedAt: time.Now(),
- IsCompleted: true,
- }); err != nil {
- c.Error(errors.NewInternalServerError(err.Error()))
- return
- }
-
- // Create assistant message (response)
- assistantMessage.CreatedAt = time.Now()
- if _, err := h.messageService.CreateMessage(ctx, assistantMessage); err != nil {
- c.Error(errors.NewInternalServerError(err.Error()))
- return
- }
-
- // Call KnowledgeQA service
- searchResults, respCh, err := h.sessionService.KnowledgeQA(ctx, session, request.Query, knowledgeBaseIDs)
- if err != nil {
- logger.ErrorWithFields(ctx, err, nil)
- c.Error(errors.NewInternalServerError(err.Error()))
- return
- }
- assistantMessage.KnowledgeReferences = searchResults
-
- // Register new stream with stream manager
- if err := h.streamManager.RegisterStream(ctx, sessionID, assistantMessage.ID, request.Query); err != nil {
- logger.GetLogger(ctx).Error("Register stream failed", "error", err)
- }
-
- // Set headers for SSE
- c.Header("Content-Type", "text/event-stream")
- c.Header("Cache-Control", "no-cache")
- c.Header("Connection", "keep-alive")
- c.Header("X-Accel-Buffering", "no")
-
- // Send knowledge references if available
- if len(searchResults) > 0 {
- logger.Debugf(ctx, "Sending reference content, total %d", len(searchResults))
- c.SSEvent("message", &types.StreamResponse{
- ID: requestID,
- ResponseType: types.ResponseTypeReferences,
- KnowledgeReferences: searchResults,
- })
- c.Writer.Flush()
- } else {
- logger.Debug(ctx, "No reference content to send")
- }
-
- // Process streamed response
- func() {
- defer func() {
- // Mark stream as completed when done
- if err := h.streamManager.CompleteStream(ctx, sessionID, assistantMessage.ID); err != nil {
- logger.GetLogger(ctx).Error("Complete stream failed", "error", err)
- }
- }()
- for response := range respCh {
- response.ID = requestID
- c.SSEvent("message", response)
- c.Writer.Flush()
- if response.ResponseType == types.ResponseTypeAnswer {
- assistantMessage.Content += response.Content
- }
- }
- assistantMessage.IsCompleted = true
- }()
-
- // Update message with final content and references
- assistantMessage.UpdatedAt = time.Now()
- if err := h.messageService.UpdateMessage(ctx, assistantMessage); err != nil {
- logger.Errorf(ctx, "Failed to update assistant message: %v", err)
- }
-
- logger.Infof(ctx, "KnowledgeQA delegation completed for session: %s", sessionID)
+ // Use shared function to handle KnowledgeQA request (no title generation for AgentQA fallback)
+ h.handleKnowledgeQARequest(ctx, c, session, request.Query, knowledgeBaseIDs, assistantMessage, false)
return
}
@@ -1156,20 +1042,6 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
c.Header("Connection", "keep-alive")
c.Header("X-Accel-Buffering", "no")
- // Send agent query event to frontend via SSE to trigger loading state immediately
- c.SSEvent("message", &types.StreamResponse{
- ID: requestID,
- ResponseType: types.ResponseTypeAgentQuery,
- Content: "Agent query processing started",
- Done: false,
- Data: map[string]interface{}{
- "session_id": sessionID,
- "query": request.Query,
- "request_id": requestID,
- },
- })
- c.Writer.Flush()
-
// Create user message
if _, err := h.messageService.CreateMessage(ctx, &types.Message{
SessionID: sessionID,
@@ -1194,17 +1066,12 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
logger.Infof(ctx, "Calling agent QA service, session ID: %s", sessionID)
- // Register new stream with stream manager
- if err := h.streamManager.RegisterStream(ctx, sessionID, assistantMessage.ID, request.Query); err != nil {
- logger.GetLogger(ctx).Error("Register stream failed", "error", err)
- }
-
// SSE headers already set earlier when sending agent_query event
eventBus := event.NewEventBus()
// Create stream handler with dedicated EventBus BEFORE calling AgentQA
streamHandler := NewAgentStreamHandler(
- ctx, c, sessionID, assistantMessage.ID, requestID,
+ ctx, sessionID, assistantMessage.ID, requestID,
assistantMessage, h.streamManager, eventBus,
)
@@ -1214,36 +1081,23 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
// Start async title generation if session has no title
if session.Title == "" {
logger.Infof(ctx, "Session has no title, starting async title generation, session ID: %s", sessionID)
- // Subscribe to title events on the dedicated EventBus
- eventBus.On(event.EventSessionTitle, func(ctx context.Context, evt event.Event) error {
- data, ok := evt.Data.(event.SessionTitleData)
- if !ok {
- return nil
- }
- // Send title update via SSE
- c.SSEvent("message", &types.StreamResponse{
- ID: requestID,
- ResponseType: types.ResponseTypeSessionTitle,
- Content: data.Title,
- Done: true,
- Data: map[string]interface{}{
- "session_id": data.SessionID,
- "title": data.Title,
- },
- })
- c.Writer.Flush()
- return nil
- })
h.sessionService.GenerateTitleAsync(ctx, session, request.Query, eventBus)
}
- // Call service to perform agent QA
+ asyncCtx := logger.CloneContext(ctx)
go func() {
- searchResults, err := h.sessionService.AgentQA(ctx, session, request.Query, assistantMessage.ID, eventBus)
+ defer func() {
+ if r := recover(); r != nil {
+ logger.ErrorWithFields(asyncCtx, errors.NewInternalServerError("Agent QA service panicked"), nil)
+ }
+ h.completeAssistantMessage(asyncCtx, assistantMessage)
+ logger.Infof(asyncCtx, "Agent QA service completed for session: %s", sessionID)
+ }()
+ err := h.sessionService.AgentQA(asyncCtx, session, request.Query, assistantMessage.ID, eventBus)
if err != nil {
- logger.ErrorWithFields(ctx, err, nil)
+ logger.ErrorWithFields(asyncCtx, err, nil)
// Emit error event to dedicated EventBus
- eventBus.Emit(ctx, event.Event{
+ eventBus.Emit(asyncCtx, event.Event{
Type: event.EventError,
SessionID: sessionID,
Data: event.ErrorData{
@@ -1254,26 +1108,94 @@ func (h *SessionHandler) AgentQA(c *gin.Context) {
})
return
}
- assistantMessage.KnowledgeReferences = searchResults
}()
// Handle events for SSE (blocking until connection is done)
- h.handleAgentEventsForSSEWithHandler(ctx, c, sessionID, assistantMessage.ID)
+ h.handleAgentEventsForSSEWithHandler(ctx, c, sessionID, assistantMessage.ID, requestID)
}
// handleAgentEventsForSSEWithHandler handles agent events for SSE streaming using an existing handler
// The handler is already subscribed to events and AgentQA is already running
+// This function polls StreamManager and pushes events to SSE, allowing graceful handling of disconnections
func (h *SessionHandler) handleAgentEventsForSSEWithHandler(
ctx context.Context,
c *gin.Context,
- sessionID, assistantMessageID string,
+ sessionID, assistantMessageID, requestID string,
) {
- // Wait for completion - events are already being handled by streamHandler
- // The connection will be closed when the gin context is done
- <-c.Request.Context().Done()
+ ticker := time.NewTicker(100 * time.Millisecond)
+ defer ticker.Stop()
- // Complete stream when done
- if err := h.streamManager.CompleteStream(ctx, sessionID, assistantMessageID); err != nil {
- logger.GetLogger(ctx).Error("Complete stream failed", "error", err)
+ lastOffset := 0
+ log := logger.GetLogger(ctx)
+
+ log.Infof("Starting pull-based SSE streaming for session=%s, message=%s", sessionID, assistantMessageID)
+
+ for {
+ select {
+ case <-c.Request.Context().Done():
+ // Connection closed, exit gracefully without panic
+ log.Infof("Client disconnected, stopping SSE streaming for session=%s, message=%s", sessionID, assistantMessageID)
+ return
+
+ case <-ticker.C:
+ // Get new events from StreamManager using offset
+ events, newOffset, err := h.streamManager.GetEvents(ctx, sessionID, assistantMessageID, lastOffset)
+ if err != nil {
+ log.Warnf("Failed to get events from stream: %v", err)
+ continue
+ }
+
+ // Send any new events
+ streamCompleted := false
+ for _, evt := range events {
+ // Build StreamResponse from StreamEvent
+ response := &types.StreamResponse{
+ ID: requestID,
+ ResponseType: evt.Type,
+ Content: evt.Content,
+ Done: evt.Done,
+ Data: evt.Data,
+ }
+
+ // Special handling for references event
+ if evt.Type == types.ResponseTypeReferences {
+ if refs, ok := evt.Data["references"].(types.References); ok {
+ response.KnowledgeReferences = refs
+ }
+ }
+
+ // Check for completion event
+ if evt.Type == "complete" {
+ streamCompleted = true
+ }
+
+ // Check if connection is still alive before writing
+ if c.Request.Context().Err() != nil {
+ log.Info("Connection closed during event sending, stopping")
+ return
+ }
+
+ c.SSEvent("message", response)
+ c.Writer.Flush()
+ }
+
+ // Update offset
+ lastOffset = newOffset
+
+ // Check if stream is completed
+ if streamCompleted {
+ log.Infof("Stream completed for session=%s, message=%s", sessionID, assistantMessageID)
+
+ // Send final completion signal
+ c.SSEvent("message", &types.StreamResponse{
+ ID: requestID,
+ ResponseType: types.ResponseTypeAnswer,
+ Content: "",
+ Done: true,
+ })
+ c.Writer.Flush()
+ return
+ }
+ }
}
}
diff --git a/internal/stream/memory_manager.go b/internal/stream/memory_manager.go
index 21d25666..22f9d5b6 100644
--- a/internal/stream/memory_manager.go
+++ b/internal/stream/memory_manager.go
@@ -5,161 +5,106 @@ import (
"sync"
"time"
- "github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
)
-// 内存流信息
-type memoryStreamInfo struct {
- sessionID string
- requestID string
- query string
- events []interfaces.StreamEvent
- knowledgeReferences types.References
- lastUpdated time.Time
- isCompleted bool
+// memoryStreamData holds stream events in memory
+type memoryStreamData struct {
+ events []interfaces.StreamEvent
+ lastUpdated time.Time
+ mu sync.RWMutex
}
-// MemoryStreamManager 基于内存的流管理器实现
+// MemoryStreamManager implements StreamManager using in-memory storage
type MemoryStreamManager struct {
- // 会话ID -> 请求ID -> 流数据
- activeStreams map[string]map[string]*memoryStreamInfo
- mu sync.RWMutex
+ // Map: sessionID -> messageID -> stream data
+ streams map[string]map[string]*memoryStreamData
+ mu sync.RWMutex
}
-// NewMemoryStreamManager 创建一个新的内存流管理器
+// NewMemoryStreamManager creates a new in-memory stream manager
func NewMemoryStreamManager() *MemoryStreamManager {
return &MemoryStreamManager{
- activeStreams: make(map[string]map[string]*memoryStreamInfo),
+ streams: make(map[string]map[string]*memoryStreamData),
}
}
-// RegisterStream 注册一个新的流
-func (m *MemoryStreamManager) RegisterStream(ctx context.Context, sessionID, requestID, query string) error {
+// getOrCreateStream gets or creates stream data
+func (m *MemoryStreamManager) getOrCreateStream(sessionID, messageID string) *memoryStreamData {
m.mu.Lock()
defer m.mu.Unlock()
- info := &memoryStreamInfo{
- sessionID: sessionID,
- requestID: requestID,
- query: query,
- lastUpdated: time.Now(),
+ if _, exists := m.streams[sessionID]; !exists {
+ m.streams[sessionID] = make(map[string]*memoryStreamData)
}
- if _, exists := m.activeStreams[sessionID]; !exists {
- m.activeStreams[sessionID] = make(map[string]*memoryStreamInfo)
- }
-
- m.activeStreams[sessionID][requestID] = info
- return nil
-}
-
-// PushEvent 推送事件到流(追加模式)
-func (m *MemoryStreamManager) PushEvent(ctx context.Context,
- sessionID, requestID string, event interfaces.StreamEvent,
-) error {
- m.mu.Lock()
- defer m.mu.Unlock()
-
- if sessionMap, exists := m.activeStreams[sessionID]; exists {
- if stream, found := sessionMap[requestID]; found {
- stream.events = append(stream.events, event)
- stream.lastUpdated = time.Now()
+ if _, exists := m.streams[sessionID][messageID]; !exists {
+ m.streams[sessionID][messageID] = &memoryStreamData{
+ events: make([]interfaces.StreamEvent, 0),
+ lastUpdated: time.Now(),
}
}
- return nil
+
+ return m.streams[sessionID][messageID]
}
-// ReplaceEvent 通过 ID 替换事件(用于流式进度更新)
-func (m *MemoryStreamManager) ReplaceEvent(ctx context.Context,
- sessionID, requestID string, event interfaces.StreamEvent,
-) error {
- m.mu.Lock()
- defer m.mu.Unlock()
-
- if sessionMap, exists := m.activeStreams[sessionID]; exists {
- if stream, found := sessionMap[requestID]; found {
- // 通过 ID 精确查找并替换
- replaced := false
- for i := range stream.events {
- if stream.events[i].ID == event.ID {
- // 找到了,替换
- stream.events[i] = event
- replaced = true
- break
- }
- }
- // 没找到,追加
- if !replaced {
- stream.events = append(stream.events, event)
- }
- stream.lastUpdated = time.Now()
- }
- }
- return nil
-}
-
-// UpdateReferences 更新知识引用
-func (m *MemoryStreamManager) UpdateReferences(ctx context.Context,
- sessionID, requestID string, references types.References,
-) error {
- m.mu.Lock()
- defer m.mu.Unlock()
-
- if sessionMap, exists := m.activeStreams[sessionID]; exists {
- if stream, found := sessionMap[requestID]; found {
- stream.knowledgeReferences = references
- stream.lastUpdated = time.Now()
- }
- }
- return nil
-}
-
-// CompleteStream 完成流
-func (m *MemoryStreamManager) CompleteStream(ctx context.Context, sessionID, requestID string) error {
- m.mu.Lock()
- defer m.mu.Unlock()
-
- if sessionMap, exists := m.activeStreams[sessionID]; exists {
- if stream, found := sessionMap[requestID]; found {
- stream.isCompleted = true
- // 30s 后删除流
- go func() {
- time.Sleep(30 * time.Second)
- m.mu.Lock()
- defer m.mu.Unlock()
- delete(sessionMap, requestID)
- if len(sessionMap) == 0 {
- delete(m.activeStreams, sessionID)
- }
- }()
- }
- }
- return nil
-}
-
-// GetStream 获取特定流
-func (m *MemoryStreamManager) GetStream(ctx context.Context,
- sessionID, requestID string,
-) (*interfaces.StreamInfo, error) {
+// getStream gets existing stream data (returns nil if not found)
+func (m *MemoryStreamManager) getStream(sessionID, messageID string) *memoryStreamData {
m.mu.RLock()
defer m.mu.RUnlock()
- if sessionMap, exists := m.activeStreams[sessionID]; exists {
- if stream, found := sessionMap[requestID]; found {
- return &interfaces.StreamInfo{
- SessionID: stream.sessionID,
- RequestID: stream.requestID,
- Query: stream.query,
- Events: stream.events,
- KnowledgeReferences: stream.knowledgeReferences,
- LastUpdated: stream.lastUpdated,
- IsCompleted: stream.isCompleted,
- }, nil
- }
+ if sessionMap, exists := m.streams[sessionID]; exists {
+ return sessionMap[messageID]
}
- return nil, nil
+ return nil
}
-// 确保实现了接口
+// AppendEvent appends a single event to the stream
+func (m *MemoryStreamManager) AppendEvent(ctx context.Context, sessionID, messageID string, event interfaces.StreamEvent) error {
+ stream := m.getOrCreateStream(sessionID, messageID)
+
+ stream.mu.Lock()
+ defer stream.mu.Unlock()
+
+ // Set timestamp if not already set
+ if event.Timestamp.IsZero() {
+ event.Timestamp = time.Now()
+ }
+
+ // Append event
+ stream.events = append(stream.events, event)
+ stream.lastUpdated = time.Now()
+
+ return nil
+}
+
+// GetEvents gets events starting from offset
+// Returns: events slice, next offset, error
+func (m *MemoryStreamManager) GetEvents(ctx context.Context, sessionID, messageID string, fromOffset int) ([]interfaces.StreamEvent, int, error) {
+ stream := m.getStream(sessionID, messageID)
+ if stream == nil {
+ // Stream doesn't exist yet
+ return []interfaces.StreamEvent{}, fromOffset, nil
+ }
+
+ stream.mu.RLock()
+ defer stream.mu.RUnlock()
+
+ // Check if offset is beyond current events
+ if fromOffset >= len(stream.events) {
+ return []interfaces.StreamEvent{}, fromOffset, nil
+ }
+
+ // Get events from offset to end
+ events := stream.events[fromOffset:]
+ nextOffset := len(stream.events)
+
+ // Return copy of events to avoid race conditions
+ eventsCopy := make([]interfaces.StreamEvent, len(events))
+ copy(eventsCopy, events)
+
+ return eventsCopy, nextOffset, nil
+ }
+
+// Ensure MemoryStreamManager implements StreamManager interface
var _ interfaces.StreamManager = (*MemoryStreamManager)(nil)
diff --git a/internal/stream/redis_manager.go b/internal/stream/redis_manager.go
index fbe4d09f..b96f6a6e 100644
--- a/internal/stream/redis_manager.go
+++ b/internal/stream/redis_manager.go
@@ -6,30 +6,18 @@ import (
"fmt"
"time"
- "github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/redis/go-redis/v9"
)
-// redisStreamInfo Redis存储的流信息
-type redisStreamInfo struct {
- SessionID string `json:"session_id"`
- RequestID string `json:"request_id"`
- Query string `json:"query"`
- Events []interfaces.StreamEvent `json:"events"`
- KnowledgeReferences types.References `json:"knowledge_references"`
- LastUpdated time.Time `json:"last_updated"`
- IsCompleted bool `json:"is_completed"`
-}
-
-// RedisStreamManager 基于Redis的流管理器实现
+// RedisStreamManager implements StreamManager using Redis Lists for append-only event streaming
type RedisStreamManager struct {
client *redis.Client
- ttl time.Duration // 流数据在Redis中的过期时间
- prefix string // Redis键前缀
+ ttl time.Duration // TTL for stream data in Redis
+ prefix string // Redis key prefix
}
-// NewRedisStreamManager 创建一个新的Redis流管理器
+// NewRedisStreamManager creates a new Redis-based stream manager
func NewRedisStreamManager(redisAddr, redisPassword string,
redisDB int, prefix string, ttl time.Duration,
) (*RedisStreamManager, error) {
@@ -39,18 +27,18 @@ func NewRedisStreamManager(redisAddr, redisPassword string,
DB: redisDB,
})
- // 验证连接
+ // Verify connection
_, err := client.Ping(context.Background()).Result()
if err != nil {
- return nil, fmt.Errorf("连接Redis失败: %w", err)
+ return nil, fmt.Errorf("failed to connect to Redis: %w", err)
}
if ttl == 0 {
- ttl = 24 * time.Hour // 默认TTL为24小时
+ ttl = 24 * time.Hour // Default TTL: 24 hours
}
if prefix == "" {
- prefix = "stream:" // 默认前缀
+ prefix = "stream:events" // Default prefix
}
return &RedisStreamManager{
@@ -60,206 +48,81 @@ func NewRedisStreamManager(redisAddr, redisPassword string,
}, nil
}
-// 构建Redis键
-func (r *RedisStreamManager) buildKey(sessionID, requestID string) string {
- return fmt.Sprintf("%s:%s:%s", r.prefix, sessionID, requestID)
+// buildKey builds the Redis key for event list
+func (r *RedisStreamManager) buildKey(sessionID, messageID string) string {
+ return fmt.Sprintf("%s:%s:%s", r.prefix, sessionID, messageID)
}
-// RegisterStream 注册一个新的流
-func (r *RedisStreamManager) RegisterStream(ctx context.Context, sessionID, requestID, query string) error {
- info := &redisStreamInfo{
- SessionID: sessionID,
- RequestID: requestID,
- Query: query,
- LastUpdated: time.Now(),
+// AppendEvent appends a single event to the stream using Redis RPush
+func (r *RedisStreamManager) AppendEvent(ctx context.Context, sessionID, messageID string, event interfaces.StreamEvent) error {
+ key := r.buildKey(sessionID, messageID)
+
+ // Set timestamp if not already set
+ if event.Timestamp.IsZero() {
+ event.Timestamp = time.Now()
}
- data, err := json.Marshal(info)
+ // Serialize event to JSON
+ eventJSON, err := json.Marshal(event)
if err != nil {
- return fmt.Errorf("序列化流信息失败: %w", err)
+ return fmt.Errorf("failed to marshal event: %w", err)
}
- key := r.buildKey(sessionID, requestID)
- return r.client.Set(ctx, key, data, r.ttl).Err()
+ // Append to Redis list with RPush (O(1) operation)
+ if err := r.client.RPush(ctx, key, eventJSON).Err(); err != nil {
+ return fmt.Errorf("failed to append event to Redis: %w", err)
+ }
+
+ // Set/refresh TTL on the key
+ if err := r.client.Expire(ctx, key, r.ttl).Err(); err != nil {
+ return fmt.Errorf("failed to set TTL: %w", err)
+ }
+
+ return nil
}
-// PushEvent 推送事件到流
-func (r *RedisStreamManager) PushEvent(ctx context.Context, sessionID, requestID string, event interfaces.StreamEvent) error {
- key := r.buildKey(sessionID, requestID)
+// GetEvents gets events starting from offset using Redis LRange
+// Returns: events slice, next offset, error
+func (r *RedisStreamManager) GetEvents(ctx context.Context, sessionID, messageID string, fromOffset int) ([]interfaces.StreamEvent, int, error) {
+ key := r.buildKey(sessionID, messageID)
- // 获取当前数据
- data, err := r.client.Get(ctx, key).Bytes()
+ // Get all events from offset to end using LRange
+ // LRange is inclusive, so fromOffset to -1 gets all remaining elements
+ results, err := r.client.LRange(ctx, key, int64(fromOffset), -1).Result()
if err != nil {
if err == redis.Nil {
- return nil // 键不存在,可能已过期
+ // Key doesn't exist - return empty slice
+ return []interfaces.StreamEvent{}, fromOffset, nil
}
- return fmt.Errorf("获取流数据失败: %w", err)
+ return nil, fromOffset, fmt.Errorf("failed to get events from Redis: %w", err)
}
- var info redisStreamInfo
- if err := json.Unmarshal(data, &info); err != nil {
- return fmt.Errorf("解析流数据失败: %w", err)
+ // No new events
+ if len(results) == 0 {
+ return []interfaces.StreamEvent{}, fromOffset, nil
}
- // 追加事件
- info.Events = append(info.Events, event)
- info.LastUpdated = time.Now()
-
- // 保存回Redis
- updatedData, err := json.Marshal(info)
- if err != nil {
- return fmt.Errorf("序列化更新的流信息失败: %w", err)
- }
-
- return r.client.Set(ctx, key, updatedData, r.ttl).Err()
+ // Unmarshal events
+ events := make([]interfaces.StreamEvent, 0, len(results))
+ for _, result := range results {
+ var event interfaces.StreamEvent
+ if err := json.Unmarshal([]byte(result), &event); err != nil {
+ // Log error but continue with other events
+ continue
+ }
+ events = append(events, event)
}
-// ReplaceEvent 通过 ID 替换事件(用于流式进度更新)
-func (r *RedisStreamManager) ReplaceEvent(ctx context.Context, sessionID, requestID string, event interfaces.StreamEvent) error {
- key := r.buildKey(sessionID, requestID)
+ // Calculate next offset
+ nextOffset := fromOffset + len(results)
- // 获取当前数据
- data, err := r.client.Get(ctx, key).Bytes()
- if err != nil {
- if err == redis.Nil {
- return nil // 键不存在,可能已过期
- }
- return fmt.Errorf("获取流数据失败: %w", err)
- }
-
- var info redisStreamInfo
- if err := json.Unmarshal(data, &info); err != nil {
- return fmt.Errorf("解析流数据失败: %w", err)
- }
-
- // 通过 ID 精确查找并替换
- replaced := false
- for i := range info.Events {
- if info.Events[i].ID == event.ID {
- // 找到了,替换
- info.Events[i] = event
- replaced = true
- break
- }
- }
-
- // 没找到,追加
- if !replaced {
- info.Events = append(info.Events, event)
- }
-
- info.LastUpdated = time.Now()
-
- // 保存回Redis
- updatedData, err := json.Marshal(info)
- if err != nil {
- return fmt.Errorf("序列化更新的流信息失败: %w", err)
- }
-
- return r.client.Set(ctx, key, updatedData, r.ttl).Err()
+ return events, nextOffset, nil
}
-// UpdateReferences 更新知识引用
-func (r *RedisStreamManager) UpdateReferences(ctx context.Context, sessionID, requestID string, references types.References) error {
- key := r.buildKey(sessionID, requestID)
-
- // 获取当前数据
- data, err := r.client.Get(ctx, key).Bytes()
- if err != nil {
- if err == redis.Nil {
- return nil // 键不存在,可能已过期
- }
- return fmt.Errorf("获取流数据失败: %w", err)
- }
-
- var info redisStreamInfo
- if err := json.Unmarshal(data, &info); err != nil {
- return fmt.Errorf("解析流数据失败: %w", err)
- }
-
- // 更新知识引用
- info.KnowledgeReferences = references
- info.LastUpdated = time.Now()
-
- // 保存回Redis
- updatedData, err := json.Marshal(info)
- if err != nil {
- return fmt.Errorf("序列化更新的流信息失败: %w", err)
- }
-
- return r.client.Set(ctx, key, updatedData, r.ttl).Err()
-}
-
-// CompleteStream 完成流
-func (r *RedisStreamManager) CompleteStream(ctx context.Context, sessionID, requestID string) error {
- key := r.buildKey(sessionID, requestID)
-
- // 获取当前数据
- data, err := r.client.Get(ctx, key).Bytes()
- if err != nil {
- if err == redis.Nil {
- return nil // 键不存在,可能已过期
- }
- return fmt.Errorf("获取流数据失败: %w", err)
- }
-
- var info redisStreamInfo
- if err := json.Unmarshal(data, &info); err != nil {
- return fmt.Errorf("解析流数据失败: %w", err)
- }
-
- // 标记为完成
- info.IsCompleted = true
- info.LastUpdated = time.Now()
-
- // 保存回Redis
- updatedData, err := json.Marshal(info)
- if err != nil {
- return fmt.Errorf("序列化更新的流信息失败: %w", err)
- }
-
- // 30s 后删除流
- go func() {
- time.Sleep(30 * time.Second)
- r.client.Del(ctx, key)
- }()
- return r.client.Set(ctx, key, updatedData, r.ttl).Err()
-}
-
-// GetStream 获取特定流
-func (r *RedisStreamManager) GetStream(ctx context.Context, sessionID, requestID string) (*interfaces.StreamInfo, error) {
- key := r.buildKey(sessionID, requestID)
-
- // 获取数据
- data, err := r.client.Get(ctx, key).Bytes()
- if err != nil {
- if err == redis.Nil {
- return nil, nil // 键不存在
- }
- return nil, fmt.Errorf("获取流数据失败: %w", err)
- }
-
- var info redisStreamInfo
- if err := json.Unmarshal(data, &info); err != nil {
- return nil, fmt.Errorf("解析流数据失败: %w", err)
- }
-
- // 转换为接口结构
- return &interfaces.StreamInfo{
- SessionID: info.SessionID,
- RequestID: info.RequestID,
- Query: info.Query,
- Events: info.Events,
- KnowledgeReferences: info.KnowledgeReferences,
- LastUpdated: info.LastUpdated,
- IsCompleted: info.IsCompleted,
- }, nil
-}
-
-// Close 关闭Redis连接
+// Close closes the Redis connection
func (r *RedisStreamManager) Close() error {
return r.client.Close()
}
-// 确保实现了接口
+// Ensure RedisStreamManager implements StreamManager interface
var _ interfaces.StreamManager = (*RedisStreamManager)(nil)
diff --git a/internal/types/chat_manage.go b/internal/types/chat_manage.go
index b92e2d3a..aa808e8e 100644
--- a/internal/types/chat_manage.go
+++ b/internal/types/chat_manage.go
@@ -20,20 +20,23 @@ type ChatManage struct {
RerankTopK int `json:"rerank_top_k"` // Number of top results after reranking
RerankThreshold float64 `json:"rerank_threshold"` // Minimum score threshold for reranked results
- ChatModelID string `json:"chat_model_id"` // Model ID for chat completion
+ ChatModelID string `json:"chat_model_id"` // ID of the chat model to use
SummaryConfig SummaryConfig `json:"summary_config"` // Configuration for summary generation
FallbackStrategy FallbackStrategy `json:"fallback_strategy"` // Strategy when no relevant results are found
FallbackResponse string `json:"fallback_response"` // Default response when fallback occurs
// Internal fields for pipeline data processing
- SearchResult []*SearchResult `json:"-"` // Results from search phase
- RerankResult []*SearchResult `json:"-"` // Results after reranking
- MergeResult []*SearchResult `json:"-"` // Final merged results after all processing
- Entity []string `json:"-"` // List of identified entities
- GraphResult *GraphData `json:"-"` // Graph data from search phase
- UserContent string `json:"-"` // Processed user content
- ChatResponse *ChatResponse `json:"-"` // Final response from chat model
- ResponseChan <-chan StreamResponse `json:"-"` // Channel for streaming responses
+ SearchResult []*SearchResult `json:"-"` // Results from search phase
+ RerankResult []*SearchResult `json:"-"` // Results after reranking
+ MergeResult []*SearchResult `json:"-"` // Final merged results after all processing
+ Entity []string `json:"-"` // List of identified entities
+ GraphResult *GraphData `json:"-"` // Graph data from search phase
+ UserContent string `json:"-"` // Processed user content
+ ChatResponse *ChatResponse `json:"-"` // Final response from chat model
+
+ // Event system for streaming responses
+ EventBus EventBusInterface `json:"-"` // EventBus for emitting streaming events
+ MessageID string `json:"-"` // Assistant message ID for event emission
}
// Clone creates a deep copy of the ChatManage object
diff --git a/internal/types/event_bus.go b/internal/types/event_bus.go
new file mode 100644
index 00000000..e93162b7
--- /dev/null
+++ b/internal/types/event_bus.go
@@ -0,0 +1,30 @@
+package types
+
+import (
+ "context"
+)
+
+// EventHandler is a function that handles events
+type EventHandler func(ctx context.Context, evt Event) error
+
+// Event represents an event in the system
+// This is a simplified version to avoid import cycle with event package
+type Event struct {
+ ID string // Event ID
+ Type EventType // Event type (uses EventType from chat_manage.go)
+ SessionID string // Session ID
+ Data interface{} // Event data
+ Metadata map[string]interface{} // Event metadata
+ RequestID string // Request ID
+}
+
+// EventBusInterface defines the interface for event bus operations
+// This interface allows types package to use EventBus without importing the concrete type
+// and avoids circular dependencies
+type EventBusInterface interface {
+ // On registers an event handler for a specific event type
+ On(eventType EventType, handler EventHandler)
+
+ // Emit publishes an event to all registered handlers
+ Emit(ctx context.Context, evt Event) error
+}
diff --git a/internal/types/interfaces/session.go b/internal/types/interfaces/session.go
index a0a13d63..abd088d6 100644
--- a/internal/types/interfaces/session.go
+++ b/internal/types/interfaces/session.go
@@ -28,16 +28,17 @@ type SessionService interface {
GenerateTitleAsync(ctx context.Context, session *types.Session, userQuery string, eventBus *event.EventBus)
// KnowledgeQA performs knowledge-based question answering
// knowledgeBaseIDs: list of knowledge base IDs to search (supports multi-KB)
+ // Events are emitted through eventBus (references, answer chunks, completion)
KnowledgeQA(ctx context.Context,
- session *types.Session, query string, knowledgeBaseIDs []string,
- ) ([]*types.SearchResult, <-chan types.StreamResponse, error)
+ session *types.Session, query string, knowledgeBaseIDs []string, assistantMessageID string, eventBus *event.EventBus,
+ ) error
// KnowledgeQAByEvent performs knowledge-based question answering by event
KnowledgeQAByEvent(ctx context.Context, chatManage *types.ChatManage, eventList []types.EventType) error
// SearchKnowledge performs knowledge-based search, without summarization
SearchKnowledge(ctx context.Context, knowledgeBaseID, query string) ([]*types.SearchResult, error)
// AgentQA performs agent-based question answering with conversation history and streaming support
// eventBus is optional - if nil, uses service's default EventBus
- AgentQA(ctx context.Context, session *types.Session, query string, assistantMessageID string, eventBus *event.EventBus) ([]*types.SearchResult, error)
+ AgentQA(ctx context.Context, session *types.Session, query string, assistantMessageID string, eventBus *event.EventBus) error
// ClearContext clears the LLM context for a session
ClearContext(ctx context.Context, sessionID string) error
}
diff --git a/internal/types/interfaces/stream_manager.go b/internal/types/interfaces/stream_manager.go
index 362e51dd..41499d05 100644
--- a/internal/types/interfaces/stream_manager.go
+++ b/internal/types/interfaces/stream_manager.go
@@ -9,43 +9,24 @@ import (
// StreamEvent represents a single event in the stream
type StreamEvent struct {
- ID string `json:"id"` // Unique event ID for precise replacement
- Type types.ResponseType `json:"type"` // Event type (thinking, tool_call, tool_result, etc.)
- Content string `json:"content"` // Event content
+ ID string `json:"id"` // Unique event ID
+ Type types.ResponseType `json:"type"` // Event type (thinking, tool_call, tool_result, references, complete, etc.)
+ Content string `json:"content"` // Event content (chunk for streaming events)
Done bool `json:"done"` // Whether this event is done
Timestamp time.Time `json:"timestamp"` // When this event occurred
- Data map[string]interface{} `json:"data,omitempty"` // Additional event data
+ Data map[string]interface{} `json:"data,omitempty"` // Additional event data (references, metadata, etc.)
}
-// StreamInfo stream information
-type StreamInfo struct {
- SessionID string // session ID
- RequestID string // request ID
- Query string // query content
- Events []StreamEvent // all events in order (for replay on refresh)
- KnowledgeReferences types.References // knowledge references
- LastUpdated time.Time // last updated time
- IsCompleted bool // whether completed
-}
-
-// StreamManager stream manager interface
+// StreamManager stream manager interface - minimal append-only design
+// All stream state is managed through events: metadata, references, completion, etc.
type StreamManager interface {
- // RegisterStream registers a new stream
- RegisterStream(ctx context.Context, sessionID, requestID, query string) error
+ // AppendEvent appends a single event to the stream
+ // Uses Redis RPush for O(1) append performance
+ // All event types (thinking, tool_call, references, complete) use this method
+ AppendEvent(ctx context.Context, sessionID, messageID string, event StreamEvent) error
- // PushEvent pushes an event to the stream (append mode)
- PushEvent(ctx context.Context, sessionID, requestID string, event StreamEvent) error
-
- // ReplaceEvent replaces an event by ID (for streaming progress updates)
- // If no matching event exists, it will append the event
- ReplaceEvent(ctx context.Context, sessionID, requestID string, event StreamEvent) error
-
- // UpdateReferences updates knowledge references
- UpdateReferences(ctx context.Context, sessionID, requestID string, references types.References) error
-
- // CompleteStream completes the stream
- CompleteStream(ctx context.Context, sessionID, requestID string) error
-
- // GetStream gets a specific stream (for replay on refresh)
- GetStream(ctx context.Context, sessionID, requestID string) (*StreamInfo, error)
+ // GetEvents gets events starting from offset
+ // Uses Redis LRange for incremental reads
+ // Returns: events slice, next offset for subsequent reads, error
+ GetEvents(ctx context.Context, sessionID, messageID string, fromOffset int) ([]StreamEvent, int, error)
}