138 lines
5.0 KiB
Go
138 lines
5.0 KiB
Go
package qa
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"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)
|
|
AgentChat(ctx context.Context, sessionID string, request weknora.AgentChatRequest) (weknora.ChatResult, error)
|
|
}
|
|
|
|
type Service struct {
|
|
repository core.Repository
|
|
agents AgentResolver
|
|
weknora WeKnora
|
|
groupPolicy session.GroupPolicy
|
|
}
|
|
|
|
func New(repository core.Repository, agents AgentResolver, client WeKnora, groupPolicy session.GroupPolicy) (*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
|
|
}
|
|
return &Service{repository: repository, agents: agents, weknora: client, groupPolicy: groupPolicy}, nil
|
|
}
|
|
|
|
func (s *Service) Ask(ctx context.Context, request core.QARequest) (core.QAResult, error) {
|
|
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,
|
|
})
|
|
}
|
|
turn := core.Turn{ID: newID(), TenantKey: request.TenantKey, Channel: request.Channel,
|
|
ExternalMessageID: request.ExternalMessageID, SessionKey: sessionKey,
|
|
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,
|
|
References: stored.References, Replayed: true}, nil
|
|
}
|
|
return core.QAResult{}, core.ErrTurnInProgress
|
|
}
|
|
turn = stored
|
|
|
|
mapping := core.SessionMapping{SessionKey: sessionKey, TenantKey: request.TenantKey,
|
|
Channel: request.Channel, AgentID: agentID, ConversationType: request.ConversationType,
|
|
ExternalSubjectID: subjectID}
|
|
sessionID, err := s.repository.ResolveSession(ctx, mapping, func(createCtx context.Context) (string, error) {
|
|
title := fmt.Sprintf("%s %s", request.Channel, subjectID)
|
|
return s.weknora.CreateSession(createCtx, title, "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
|
|
|
|
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})
|
|
}
|
|
chat, err := s.weknora.AgentChat(ctx, sessionID, weknora.AgentChatRequest{
|
|
Query: query, AgentID: agentID, AgentEnabled: true, Channel: "im", EnableMemory: true,
|
|
Images: images,
|
|
})
|
|
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
|
|
if err := s.repository.FinishTurn(ctx, turn); err != nil {
|
|
return core.QAResult{}, fmt.Errorf("finish turn: %w", err)
|
|
}
|
|
return core.QAResult{TurnID: turn.ID, WeKnoraSessionID: sessionID,
|
|
WeKnoraRequestID: chat.RequestID, Answer: chat.Answer, References: chat.References}, nil
|
|
}
|
|
|
|
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[:])
|
|
}
|