323 lines
12 KiB
Go
323 lines
12 KiB
Go
package qa
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/core"
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/session"
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/weknora"
|
|
)
|
|
|
|
type AgentResolver interface {
|
|
Resolve(channel, externalChatID string) (string, error)
|
|
}
|
|
|
|
type WeKnora interface {
|
|
CreateSession(ctx context.Context, title, description string) (string, error)
|
|
UpdateSessionTitle(ctx context.Context, sessionID, title, description string) error
|
|
AgentChat(ctx context.Context, sessionID string, request weknora.AgentChatRequest) (weknora.ChatResult, error)
|
|
}
|
|
|
|
type streamingWeKnora interface {
|
|
AgentChatStream(ctx context.Context, sessionID string, request weknora.AgentChatRequest, observer weknora.AnswerObserver) (weknora.ChatResult, error)
|
|
}
|
|
|
|
type eventStreamingWeKnora interface {
|
|
AgentChatEvents(ctx context.Context, sessionID string, request weknora.AgentChatRequest, observer weknora.StreamObserver) (weknora.ChatResult, error)
|
|
}
|
|
|
|
// SucceededTurnObserver observes a successfully finished turn. It is called
|
|
// synchronously after FinishTurn succeeds and before the QAResult is returned.
|
|
// A non-nil error from ObserveSucceededTurn must never change the QAResult or
|
|
// cause Ask to return an error.
|
|
type SucceededTurnObserver interface {
|
|
ObserveSucceededTurn(ctx context.Context, turn core.Turn) error
|
|
}
|
|
|
|
// ServiceOption configures a Service.
|
|
type ServiceOption func(*Service)
|
|
|
|
// WithSucceededTurnObserver registers an observer that is called synchronously
|
|
// after each successful turn finishes. onError, if non-nil, is called with any
|
|
// error returned by the observer. The observer error is never returned to the
|
|
// caller.
|
|
func WithSucceededTurnObserver(observer SucceededTurnObserver, onError func(error)) ServiceOption {
|
|
return func(s *Service) {
|
|
s.observerConfigured = true
|
|
s.observer = observer
|
|
s.observerErrorHandler = onError
|
|
}
|
|
}
|
|
|
|
type Service struct {
|
|
repository core.Repository
|
|
agents AgentResolver
|
|
weknora WeKnora
|
|
groupPolicy session.GroupPolicy
|
|
observer SucceededTurnObserver
|
|
observerErrorHandler func(error)
|
|
observerConfigured bool
|
|
}
|
|
|
|
func New(repository core.Repository, agents AgentResolver, client WeKnora, groupPolicy session.GroupPolicy, opts ...ServiceOption) (*Service, error) {
|
|
if repository == nil || agents == nil || client == nil {
|
|
return nil, errors.New("repository, agent resolver and weknora client are required")
|
|
}
|
|
if groupPolicy == "" {
|
|
groupPolicy = session.GroupShared
|
|
}
|
|
s := &Service{repository: repository, agents: agents, weknora: client, groupPolicy: groupPolicy}
|
|
for _, o := range opts {
|
|
o(s)
|
|
}
|
|
if s.observerConfigured && isNilSucceededTurnObserver(s.observer) {
|
|
return nil, errors.New("succeeded turn observer is required when configured")
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func isNilSucceededTurnObserver(observer SucceededTurnObserver) bool {
|
|
if observer == nil {
|
|
return true
|
|
}
|
|
v := reflect.ValueOf(observer)
|
|
return v.Kind() == reflect.Pointer && v.IsNil()
|
|
}
|
|
|
|
func (s *Service) Ask(ctx context.Context, request core.QARequest) (core.QAResult, error) {
|
|
return s.ask(ctx, request, nil, nil)
|
|
}
|
|
|
|
func (s *Service) AskStream(ctx context.Context, request core.QARequest, observer weknora.AnswerObserver) (core.QAResult, error) {
|
|
return s.ask(ctx, request, observer, nil)
|
|
}
|
|
|
|
func (s *Service) AskEvents(ctx context.Context, request core.QARequest, observer weknora.StreamObserver) (core.QAResult, error) {
|
|
return s.ask(ctx, request, nil, observer)
|
|
}
|
|
|
|
func (s *Service) RecordDelivery(ctx context.Context, update core.DeliveryUpdate) error {
|
|
return s.repository.RecordDelivery(ctx, update)
|
|
}
|
|
|
|
func (s *Service) ask(ctx context.Context, request core.QARequest, answerObserver weknora.AnswerObserver, eventObserver weknora.StreamObserver) (core.QAResult, error) {
|
|
request = normalizeRequestIdentity(request)
|
|
if err := validateRequest(request); err != nil {
|
|
return core.QAResult{}, err
|
|
}
|
|
agentID, err := s.agents.Resolve(request.Channel, request.ExternalChatID)
|
|
if err != nil {
|
|
return core.QAResult{}, err
|
|
}
|
|
sessionKey, subjectID, err := session.BuildKey(session.Identity{
|
|
TenantKey: request.TenantKey, Channel: request.Channel, AgentID: agentID,
|
|
ConversationType: request.ConversationType, ExternalChatID: request.ExternalChatID,
|
|
ExternalUserID: request.ExternalUserID, GroupPolicy: s.groupPolicy,
|
|
})
|
|
if err != nil {
|
|
return core.QAResult{}, err
|
|
}
|
|
|
|
media := make([]core.MediaAudit, 0, len(request.Images))
|
|
for _, image := range request.Images {
|
|
media = append(media, core.MediaAudit{
|
|
Type: "image", MIMEType: image.MIMEType, SizeBytes: image.SizeBytes,
|
|
Width: image.Width, Height: image.Height,
|
|
})
|
|
}
|
|
messageType := normalizeMessageType(request)
|
|
if messageType == "" {
|
|
return core.QAResult{}, errors.New("unsupported message_type")
|
|
}
|
|
turn := core.Turn{
|
|
ID: newID(),
|
|
TenantKey: request.TenantKey,
|
|
Channel: request.Channel,
|
|
ExternalMessageID: request.ExternalMessageID,
|
|
SessionKey: sessionKey,
|
|
AgentID: agentID,
|
|
ConversationType: request.ConversationType,
|
|
ConversationTitle: request.ConversationTitle,
|
|
ExternalChatID: request.ExternalChatID,
|
|
ExternalUserID: request.ExternalUserID,
|
|
SenderName: request.SenderName,
|
|
TriggerPersonSnapshot: request.TriggerPersonSnapshot,
|
|
ActorUnionIDSnapshot: request.ActorUnionIDSnapshot,
|
|
DepartmentSnapshot: request.Department,
|
|
RegionSnapshot: request.Region,
|
|
MessageType: messageType,
|
|
ActorID: newID(),
|
|
ConversationID: newID(),
|
|
RequestMessageID: newID(),
|
|
Question: request.Query,
|
|
Media: media,
|
|
Status: "processing",
|
|
}
|
|
stored, created, err := s.repository.BeginTurn(ctx, turn)
|
|
if err != nil {
|
|
return core.QAResult{}, fmt.Errorf("begin turn: %w", err)
|
|
}
|
|
if !created {
|
|
if stored.Status == "succeeded" {
|
|
return core.QAResult{TurnID: stored.ID, WeKnoraSessionID: stored.WeKnoraSessionID,
|
|
WeKnoraRequestID: stored.WeKnoraRequestID, Answer: stored.Answer,
|
|
AnswerMessageID: stored.AnswerMessageID, DeliveryStatus: stored.AnswerDeliveryStatus,
|
|
References: stored.References, Replayed: true}, nil
|
|
}
|
|
return core.QAResult{}, core.ErrTurnInProgress
|
|
}
|
|
turn = stored
|
|
|
|
displayTitle := session.BuildDisplayTitle(session.TitleIdentity{
|
|
ConversationType: request.ConversationType,
|
|
ExternalUserID: request.ExternalUserID,
|
|
ExternalChatID: request.ExternalChatID,
|
|
SenderName: request.SenderName,
|
|
ConversationTitle: request.ConversationTitle,
|
|
})
|
|
mapping := core.SessionMapping{SessionKey: sessionKey, TenantKey: request.TenantKey,
|
|
Channel: request.Channel, AgentID: agentID, ConversationType: request.ConversationType,
|
|
ExternalSubjectID: subjectID, DisplayTitle: displayTitle}
|
|
sessionID, err := s.repository.ResolveSession(ctx, mapping, func(createCtx context.Context) (string, error) {
|
|
return s.weknora.CreateSession(createCtx, displayTitle, "Managed by DobotAI; business state remains outside WeKnora")
|
|
})
|
|
if err != nil {
|
|
turn.Status, turn.ErrorMessage = "failed", err.Error()
|
|
_ = s.repository.FinishTurn(ctx, turn)
|
|
return core.QAResult{}, fmt.Errorf("resolve weknora session: %w", err)
|
|
}
|
|
turn.WeKnoraSessionID = sessionID
|
|
_ = s.repository.SyncSessionTitle(ctx, mapping, displayTitle, func(updateCtx context.Context, existingSessionID, title string) error {
|
|
return s.weknora.UpdateSessionTitle(updateCtx, existingSessionID, title, "Managed by DobotAI; business state remains outside WeKnora")
|
|
})
|
|
|
|
query := request.Query
|
|
if request.ConversationType == core.ConversationGroup && strings.TrimSpace(request.SenderName) != "" {
|
|
query = request.SenderName + ": " + request.Query
|
|
}
|
|
images := make([]weknora.Image, 0, len(request.Images))
|
|
for _, image := range request.Images {
|
|
images = append(images, weknora.Image{Data: image.DataURI})
|
|
}
|
|
chatRequest := weknora.AgentChatRequest{
|
|
Query: query, AgentID: agentID, AgentEnabled: true, Channel: "im", EnableMemory: true,
|
|
Images: images,
|
|
}
|
|
var chat weknora.ChatResult
|
|
if eventObserver != nil {
|
|
// Prefer AgentChatEvents; fallback to AgentChatStream adaptation; then AgentChat.
|
|
if eventStream, ok := s.weknora.(eventStreamingWeKnora); ok {
|
|
chat, err = eventStream.AgentChatEvents(ctx, sessionID, chatRequest, eventObserver)
|
|
} else if streaming, ok := s.weknora.(streamingWeKnora); ok {
|
|
// Adapt AgentChatStream answer chunks to StreamEvent
|
|
chat, err = streaming.AgentChatStream(ctx, sessionID, chatRequest, func(full string) {
|
|
if answerObserver != nil {
|
|
answerObserver(full)
|
|
}
|
|
eventObserver(weknora.StreamEvent{
|
|
ResponseType: "answer",
|
|
FullAnswer: full,
|
|
})
|
|
})
|
|
} else {
|
|
chat, err = s.weknora.AgentChat(ctx, sessionID, chatRequest)
|
|
if err == nil && strings.TrimSpace(chat.Answer) != "" {
|
|
if answerObserver != nil {
|
|
answerObserver(chat.Answer)
|
|
}
|
|
eventObserver(weknora.StreamEvent{
|
|
ResponseType: "answer",
|
|
FullAnswer: chat.Answer,
|
|
Done: true,
|
|
})
|
|
}
|
|
}
|
|
} else if answerObserver != nil {
|
|
if streaming, ok := s.weknora.(streamingWeKnora); ok {
|
|
chat, err = streaming.AgentChatStream(ctx, sessionID, chatRequest, answerObserver)
|
|
} else {
|
|
chat, err = s.weknora.AgentChat(ctx, sessionID, chatRequest)
|
|
if err == nil && strings.TrimSpace(chat.Answer) != "" {
|
|
answerObserver(chat.Answer)
|
|
}
|
|
}
|
|
} else {
|
|
chat, err = s.weknora.AgentChat(ctx, sessionID, chatRequest)
|
|
}
|
|
if err == nil && strings.TrimSpace(chat.Answer) == "" {
|
|
err = weknora.ErrEmptyAnswer
|
|
}
|
|
if err != nil {
|
|
turn.Status, turn.ErrorMessage = "failed", err.Error()
|
|
_ = s.repository.FinishTurn(ctx, turn)
|
|
return core.QAResult{}, fmt.Errorf("weknora agent chat: %w", err)
|
|
}
|
|
turn.Status, turn.Answer, turn.References = "succeeded", chat.Answer, chat.References
|
|
turn.WeKnoraRequestID = chat.RequestID
|
|
turn.AnswerMessageID = newID()
|
|
if err := s.repository.FinishTurn(ctx, turn); err != nil {
|
|
return core.QAResult{}, fmt.Errorf("finish turn: %w", err)
|
|
}
|
|
if s.observer != nil {
|
|
if obsErr := s.observer.ObserveSucceededTurn(ctx, turn); obsErr != nil && s.observerErrorHandler != nil {
|
|
s.observerErrorHandler(obsErr)
|
|
}
|
|
}
|
|
return core.QAResult{TurnID: turn.ID, AnswerMessageID: turn.AnswerMessageID,
|
|
DeliveryStatus: core.DeliveryGenerated, WeKnoraSessionID: sessionID,
|
|
WeKnoraRequestID: chat.RequestID, Answer: chat.Answer, References: chat.References}, nil
|
|
}
|
|
|
|
func normalizeRequestIdentity(request core.QARequest) core.QARequest {
|
|
request.TenantKey = strings.TrimSpace(request.TenantKey)
|
|
request.Channel = strings.TrimSpace(request.Channel)
|
|
request.ConversationType = core.ConversationType(strings.TrimSpace(string(request.ConversationType)))
|
|
request.ExternalChatID = strings.TrimSpace(request.ExternalChatID)
|
|
request.ExternalUserID = strings.TrimSpace(request.ExternalUserID)
|
|
request.ExternalMessageID = strings.TrimSpace(request.ExternalMessageID)
|
|
request.SenderName = strings.TrimSpace(request.SenderName)
|
|
return request
|
|
}
|
|
|
|
func normalizeMessageType(request core.QARequest) string {
|
|
messageType := strings.ToLower(strings.TrimSpace(request.MessageType))
|
|
if messageType == "" {
|
|
if len(request.Images) > 0 {
|
|
return "image"
|
|
}
|
|
return "text"
|
|
}
|
|
switch messageType {
|
|
case "picture", "image":
|
|
return "image"
|
|
case "richtext", "rich_text":
|
|
return "rich_text"
|
|
case "text":
|
|
return messageType
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func validateRequest(request core.QARequest) error {
|
|
if strings.TrimSpace(request.TenantKey) == "" || strings.TrimSpace(request.Channel) == "" ||
|
|
strings.TrimSpace(request.ExternalMessageID) == "" || strings.TrimSpace(request.Query) == "" {
|
|
return errors.New("tenant_key, channel, external_message_id and query are required")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func newID() string {
|
|
var raw [16]byte
|
|
if _, err := rand.Read(raw[:]); err != nil {
|
|
panic("crypto/rand unavailable")
|
|
}
|
|
return hex.EncodeToString(raw[:])
|
|
}
|