Files
dobotai-platform/internal/qa/service.go
T
2026-07-20 18:21:47 +08:00

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[:])
}