063809896a
- Updated logic to manage <think> and </think> tags in chat message content, ensuring accurate representation of thinking states. - Introduced a new function to handle the closing of thinking events, enhancing clarity and reducing redundancy in event emissions. - Adjusted event handling for reasoning content to support historical message reconstruction, improving user experience during chat interactions.
200 lines
6.0 KiB
Go
200 lines
6.0 KiB
Go
package chatpipeline
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/Tencent/WeKnora/internal/event"
|
|
"github.com/Tencent/WeKnora/internal/types"
|
|
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
// PluginChatCompletionStream implements streaming chat completion functionality
|
|
// as a plugin that can be registered to EventManager
|
|
type PluginChatCompletionStream struct {
|
|
modelService interfaces.ModelService // Interface for model operations
|
|
}
|
|
|
|
// NewPluginChatCompletionStream creates a new PluginChatCompletionStream instance
|
|
// and registers it with the EventManager
|
|
func NewPluginChatCompletionStream(eventManager *EventManager,
|
|
modelService interfaces.ModelService,
|
|
) *PluginChatCompletionStream {
|
|
res := &PluginChatCompletionStream{
|
|
modelService: modelService,
|
|
}
|
|
eventManager.Register(res)
|
|
return res
|
|
}
|
|
|
|
// ActivationEvents returns the event types this plugin handles
|
|
func (p *PluginChatCompletionStream) ActivationEvents() []types.EventType {
|
|
return []types.EventType{types.CHAT_COMPLETION_STREAM}
|
|
}
|
|
|
|
// OnEvent handles streaming chat completion events
|
|
// It prepares the chat model, messages, and initiates streaming response
|
|
func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
|
|
eventType types.EventType, chatManage *types.ChatManage, next func() *PluginError,
|
|
) *PluginError {
|
|
pipelineInfo(ctx, "Stream", "input", map[string]interface{}{
|
|
"session_id": chatManage.SessionID,
|
|
"user_question": chatManage.UserContent,
|
|
"history_rounds": len(chatManage.History),
|
|
"chat_model": chatManage.ChatModelID,
|
|
})
|
|
|
|
// Prepare chat model and options
|
|
chatModel, opt, err := prepareChatModel(ctx, p.modelService, chatManage)
|
|
if err != nil {
|
|
return ErrGetChatModel.WithError(err)
|
|
}
|
|
|
|
// Prepare base messages without history
|
|
|
|
chatMessages := prepareMessagesWithHistory(chatManage)
|
|
pipelineInfo(ctx, "Stream", "messages_ready", map[string]interface{}{
|
|
"message_count": len(chatMessages),
|
|
"system_prompt": chatMessages[0].Content,
|
|
})
|
|
pipelineInfo(ctx, "Stream", "user_message", map[string]interface{}{
|
|
"content": chatMessages[len(chatMessages)-1].Content,
|
|
})
|
|
// EventBus is required for event-driven streaming
|
|
if chatManage.EventBus == nil {
|
|
pipelineError(ctx, "Stream", "eventbus_missing", map[string]interface{}{
|
|
"session_id": chatManage.SessionID,
|
|
})
|
|
return ErrModelCall.WithError(errors.New("EventBus is required for streaming"))
|
|
}
|
|
eventBus := chatManage.EventBus
|
|
|
|
pipelineInfo(ctx, "Stream", "eventbus_ready", map[string]interface{}{
|
|
"session_id": chatManage.SessionID,
|
|
})
|
|
|
|
// Initiate streaming chat model call with independent context
|
|
pipelineInfo(ctx, "Stream", "model_call", map[string]interface{}{
|
|
"chat_model": chatManage.ChatModelID,
|
|
})
|
|
responseChan, err := chatModel.ChatStream(ctx, chatMessages, opt)
|
|
if err != nil {
|
|
pipelineError(ctx, "Stream", "model_call", map[string]interface{}{
|
|
"chat_model": chatManage.ChatModelID,
|
|
"error": err.Error(),
|
|
})
|
|
return ErrModelCall.WithError(err)
|
|
}
|
|
if responseChan == nil {
|
|
pipelineError(ctx, "Stream", "model_call", map[string]interface{}{
|
|
"chat_model": chatManage.ChatModelID,
|
|
"error": "nil_channel",
|
|
})
|
|
return ErrModelCall.WithError(errors.New("chat stream returned nil channel"))
|
|
}
|
|
|
|
pipelineInfo(ctx, "Stream", "model_started", map[string]interface{}{
|
|
"session_id": chatManage.SessionID,
|
|
})
|
|
|
|
// Start goroutine to consume channel and emit events directly.
|
|
// reasoning_content is routed to EventAgentThought (SSE response_type=thinking)
|
|
// and plain answer text to EventAgentFinalAnswer, matching the Agent pipeline.
|
|
// The goroutine monitors ctx.Done() to avoid leaking when the context is cancelled
|
|
// and the upstream channel is not closed promptly.
|
|
go func() {
|
|
thinkingID := fmt.Sprintf("%s-thinking", uuid.New().String()[:8])
|
|
answerID := fmt.Sprintf("%s-answer", uuid.New().String()[:8])
|
|
thinkingOpen := false
|
|
|
|
closeThinking := func() {
|
|
if !thinkingOpen {
|
|
return
|
|
}
|
|
eventBus.Emit(ctx, types.Event{
|
|
ID: thinkingID,
|
|
Type: types.EventType(event.EventAgentThought),
|
|
SessionID: chatManage.SessionID,
|
|
Data: event.AgentThoughtData{
|
|
Done: true,
|
|
},
|
|
})
|
|
thinkingOpen = false
|
|
}
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
closeThinking()
|
|
pipelineInfo(ctx, "Stream", "context_cancelled", map[string]interface{}{
|
|
"session_id": chatManage.SessionID,
|
|
})
|
|
return
|
|
|
|
case response, ok := <-responseChan:
|
|
if !ok {
|
|
closeThinking()
|
|
pipelineInfo(ctx, "Stream", "channel_close", map[string]interface{}{
|
|
"session_id": chatManage.SessionID,
|
|
})
|
|
return
|
|
}
|
|
|
|
if response.ResponseType == types.ResponseTypeError {
|
|
pipelineError(ctx, "Stream", "stream_error", map[string]interface{}{
|
|
"session_id": chatManage.SessionID,
|
|
"error": response.Content,
|
|
})
|
|
eventBus.Emit(ctx, types.Event{
|
|
ID: fmt.Sprintf("%s-error", uuid.New().String()[:8]),
|
|
Type: types.EventType(event.EventError),
|
|
SessionID: chatManage.SessionID,
|
|
Data: event.ErrorData{
|
|
Error: response.Content,
|
|
Stage: "chat_completion_stream",
|
|
SessionID: chatManage.SessionID,
|
|
},
|
|
})
|
|
continue
|
|
}
|
|
|
|
if response.ResponseType == types.ResponseTypeThinking {
|
|
if response.Content != "" {
|
|
thinkingOpen = true
|
|
eventBus.Emit(ctx, types.Event{
|
|
ID: thinkingID,
|
|
Type: types.EventType(event.EventAgentThought),
|
|
SessionID: chatManage.SessionID,
|
|
Data: event.AgentThoughtData{
|
|
Content: response.Content,
|
|
Done: false,
|
|
},
|
|
})
|
|
}
|
|
if response.Done {
|
|
closeThinking()
|
|
}
|
|
continue
|
|
}
|
|
|
|
if response.ResponseType == types.ResponseTypeAnswer {
|
|
closeThinking()
|
|
eventBus.Emit(ctx, types.Event{
|
|
ID: answerID,
|
|
Type: types.EventType(event.EventAgentFinalAnswer),
|
|
SessionID: chatManage.SessionID,
|
|
Data: event.AgentFinalAnswerData{
|
|
Content: response.Content,
|
|
Done: response.Done,
|
|
},
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
|
|
return next()
|
|
}
|