feat: Enhance AI Agent and Channel Management
- Updated labels in the AI Agents dashboard for clarity, changing "流程状态" to "Playbook 状态" and "未发布流程" to "未发布 Playbook". - Introduced AI Agent rollout percentage management in channel editing, allowing users to set and rollback rollout percentages. - Added new API endpoints for rolling back AI Agent rollout and fetching agent run metrics. - Implemented new UI components for displaying agent run details, including status, duration, and input/output tokens. - Enhanced type definitions for AdminChannel and AIAgent to include rollout percentages and runtime modes. - Updated navigation to include a section for agent runs. - Added new translations for agent run features in both English and Chinese.
This commit is contained in:
mlogclub
@@ -0,0 +1,37 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"agent-desk/internal/pkg/dto/request"
|
||||
"agent-desk/internal/pkg/dto/response"
|
||||
"agent-desk/internal/pkg/errorsx"
|
||||
)
|
||||
|
||||
var AgentEvaluationService = newAgentEvaluationService()
|
||||
var AgentEvaluationRunHook func(context.Context, request.RunAgentEvaluationRequest) (*response.AgentEvaluationReportResponse, error)
|
||||
|
||||
type agentEvaluationService struct{}
|
||||
|
||||
func newAgentEvaluationService() *agentEvaluationService { return &agentEvaluationService{} }
|
||||
|
||||
func (s *agentEvaluationService) Run(ctx context.Context, req request.RunAgentEvaluationRequest) (*response.AgentEvaluationReportResponse, error) {
|
||||
if req.AIAgentID <= 0 {
|
||||
return nil, errorsx.InvalidParam("ai agent id is required")
|
||||
}
|
||||
if strings.TrimSpace(req.EngineCode) == "" {
|
||||
return nil, errorsx.InvalidParam("engine code is required")
|
||||
}
|
||||
if len(req.Cases) == 0 {
|
||||
return nil, errorsx.InvalidParam("evaluation cases are required")
|
||||
}
|
||||
if len(req.Cases) > 100 {
|
||||
return nil, errorsx.InvalidParam("evaluation case limit exceeded")
|
||||
}
|
||||
if AgentEvaluationRunHook == nil {
|
||||
return nil, fmt.Errorf("agent evaluation runner is not initialized")
|
||||
}
|
||||
return AgentEvaluationRunHook(ctx, req)
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"agent-desk/internal/pkg/dto/request"
|
||||
"agent-desk/internal/pkg/dto/response"
|
||||
)
|
||||
|
||||
func TestAgentEvaluationServiceValidatesAndCallsRunner(t *testing.T) {
|
||||
previous := AgentEvaluationRunHook
|
||||
t.Cleanup(func() { AgentEvaluationRunHook = previous })
|
||||
called := false
|
||||
AgentEvaluationRunHook = func(_ context.Context, req request.RunAgentEvaluationRequest) (*response.AgentEvaluationReportResponse, error) {
|
||||
called = true
|
||||
return &response.AgentEvaluationReportResponse{EngineCode: req.EngineCode, Total: len(req.Cases)}, nil
|
||||
}
|
||||
result, err := AgentEvaluationService.Run(context.Background(), request.RunAgentEvaluationRequest{AIAgentID: 1, EngineCode: "autonomous", Cases: []request.AgentEvaluationCase{{ID: "faq", Message: "hello"}}})
|
||||
if err != nil || !called || result.Total != 1 {
|
||||
t.Fatalf("result=%#v called=%t err=%v", result, called, err)
|
||||
}
|
||||
if _, err := AgentEvaluationService.Run(context.Background(), request.RunAgentEvaluationRequest{}); err == nil {
|
||||
t.Fatal("expected invalid request")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"agent-desk/internal/models"
|
||||
"agent-desk/internal/pkg/dto"
|
||||
"agent-desk/internal/pkg/enums"
|
||||
"agent-desk/internal/pkg/errorsx"
|
||||
"agent-desk/internal/pkg/utils"
|
||||
"agent-desk/internal/repositories"
|
||||
|
||||
"github.com/mlogclub/simple/sqls"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
var AgentRevisionService = newAgentRevisionService()
|
||||
|
||||
func newAgentRevisionService() *agentRevisionService {
|
||||
return &agentRevisionService{}
|
||||
}
|
||||
|
||||
type agentRevisionService struct{}
|
||||
|
||||
func (s *agentRevisionService) Get(id int64) *models.AgentRevision {
|
||||
if id <= 0 {
|
||||
return nil
|
||||
}
|
||||
return repositories.AgentRevisionRepository.Get(sqls.DB(), id)
|
||||
}
|
||||
|
||||
func (s *agentRevisionService) FindByAgentID(agentID int64) []models.AgentRevision {
|
||||
return repositories.AgentRevisionRepository.FindByAgentID(sqls.DB(), agentID)
|
||||
}
|
||||
|
||||
type agentRevisionDefinition struct {
|
||||
Agent agentRevisionAgent `json:"agent"`
|
||||
Model agentRevisionModel `json:"model"`
|
||||
WorkflowVersionID int64 `json:"workflowVersionId"`
|
||||
WorkflowDefinition string `json:"workflowDefinition"`
|
||||
}
|
||||
|
||||
// agentRevisionModel deliberately excludes APIKey. A revision must capture
|
||||
// reproducible routing/model parameters without duplicating credentials.
|
||||
type agentRevisionModel struct {
|
||||
ConfigID int64 `json:"configId"`
|
||||
Provider string `json:"provider"`
|
||||
BaseURL string `json:"baseUrl"`
|
||||
ModelType string `json:"modelType"`
|
||||
ModelName string `json:"modelName"`
|
||||
MaxContextTokens int `json:"maxContextTokens"`
|
||||
MaxOutputTokens int `json:"maxOutputTokens"`
|
||||
TimeoutMS int `json:"timeoutMs"`
|
||||
MaxRetryCount int `json:"maxRetryCount"`
|
||||
}
|
||||
|
||||
type agentRevisionAgent struct {
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
AIConfigID int64 `json:"aiConfigId"`
|
||||
RuntimeMode string `json:"runtimeMode"`
|
||||
MaxSteps int `json:"maxSteps"`
|
||||
ContextWindow int `json:"contextWindow"`
|
||||
ToolPolicy string `json:"toolPolicy"`
|
||||
KnowledgePolicy string `json:"knowledgePolicy"`
|
||||
ServiceMode int `json:"serviceMode"`
|
||||
SystemPrompt string `json:"systemPrompt"`
|
||||
WelcomeMessage string `json:"welcomeMessage"`
|
||||
ReplyTimeoutSeconds int `json:"replyTimeoutSeconds"`
|
||||
TeamIDs string `json:"teamIds"`
|
||||
HandoffMode int `json:"handoffMode"`
|
||||
FallbackMode int `json:"fallbackMode"`
|
||||
FallbackMessage string `json:"fallbackMessage"`
|
||||
KnowledgeIDs string `json:"knowledgeIds"`
|
||||
SkillIDs string `json:"skillIds"`
|
||||
AllowedMCPTools string `json:"allowedMcpTools"`
|
||||
}
|
||||
|
||||
// AgentRevisionSnapshot is the immutable runtime configuration restored from
|
||||
// a published revision. Model credentials deliberately remain on the current
|
||||
// AIConfig so credential rotation does not require republishing every Agent.
|
||||
type AgentRevisionSnapshot struct {
|
||||
Revision models.AgentRevision
|
||||
Agent models.AIAgent
|
||||
AIConfig models.AIConfig
|
||||
}
|
||||
|
||||
// ResolvePublishedSnapshot restores a published Agent revision for runtime
|
||||
// execution. Empty legacy definitions retain the current fields so historical
|
||||
// records created before snapshot hydration remain executable.
|
||||
func (s *agentRevisionService) ResolvePublishedSnapshot(agent models.AIAgent, config models.AIConfig) (*AgentRevisionSnapshot, error) {
|
||||
if agent.PublishedRevisionID <= 0 {
|
||||
return nil, errorsx.InvalidParam("autonomous agent is not published")
|
||||
}
|
||||
revision := repositories.AgentRevisionRepository.Get(sqls.DB(), agent.PublishedRevisionID)
|
||||
if revision == nil || revision.AgentID != agent.ID || revision.Status != enums.StatusOk {
|
||||
return nil, errorsx.InvalidParam("autonomous agent published revision does not exist")
|
||||
}
|
||||
snapshot := &AgentRevisionSnapshot{Revision: *revision, Agent: agent, AIConfig: config}
|
||||
if strings.TrimSpace(revision.Definition) == "" {
|
||||
return snapshot, nil
|
||||
}
|
||||
definition := agentRevisionDefinition{}
|
||||
if err := json.Unmarshal([]byte(revision.Definition), &definition); err != nil {
|
||||
return nil, errorsx.InvalidParam("autonomous agent published revision is invalid")
|
||||
}
|
||||
if definition.Agent.AIConfigID > 0 && definition.Agent.AIConfigID != config.ID {
|
||||
return nil, errorsx.InvalidParam("published agent model config no longer matches")
|
||||
}
|
||||
applyRevisionAgentSnapshot(&snapshot.Agent, definition.Agent)
|
||||
if definition.WorkflowVersionID > 0 {
|
||||
snapshot.Agent.WorkflowVersionID = definition.WorkflowVersionID
|
||||
}
|
||||
applyRevisionModelSnapshot(&snapshot.AIConfig, definition.Model)
|
||||
return snapshot, nil
|
||||
}
|
||||
|
||||
func applyRevisionAgentSnapshot(agent *models.AIAgent, definition agentRevisionAgent) {
|
||||
if agent == nil {
|
||||
return
|
||||
}
|
||||
agent.Name = definition.Name
|
||||
agent.Description = definition.Description
|
||||
agent.AIConfigID = definition.AIConfigID
|
||||
agent.RuntimeMode = enums.AIAgentRuntimeMode(definition.RuntimeMode)
|
||||
agent.MaxSteps = definition.MaxSteps
|
||||
agent.ContextWindow = definition.ContextWindow
|
||||
agent.ToolPolicy = definition.ToolPolicy
|
||||
agent.KnowledgePolicy = definition.KnowledgePolicy
|
||||
agent.ServiceMode = enums.IMConversationServiceMode(definition.ServiceMode)
|
||||
agent.SystemPrompt = definition.SystemPrompt
|
||||
agent.WelcomeMessage = definition.WelcomeMessage
|
||||
agent.ReplyTimeoutSeconds = definition.ReplyTimeoutSeconds
|
||||
agent.TeamIDs = definition.TeamIDs
|
||||
agent.HandoffMode = enums.AIAgentHandoffMode(definition.HandoffMode)
|
||||
agent.FallbackMode = enums.AIAgentFallbackMode(definition.FallbackMode)
|
||||
agent.FallbackMessage = definition.FallbackMessage
|
||||
agent.KnowledgeIDs = definition.KnowledgeIDs
|
||||
agent.SkillIDs = definition.SkillIDs
|
||||
agent.AllowedMCPTools = definition.AllowedMCPTools
|
||||
}
|
||||
|
||||
func applyRevisionModelSnapshot(config *models.AIConfig, definition agentRevisionModel) {
|
||||
if config == nil || definition.ConfigID <= 0 {
|
||||
return
|
||||
}
|
||||
config.Provider = enums.AIProvider(definition.Provider)
|
||||
config.BaseURL = definition.BaseURL
|
||||
config.ModelType = enums.AIModelType(definition.ModelType)
|
||||
config.ModelName = definition.ModelName
|
||||
config.MaxContextTokens = definition.MaxContextTokens
|
||||
config.MaxOutputTokens = definition.MaxOutputTokens
|
||||
config.TimeoutMS = definition.TimeoutMS
|
||||
config.MaxRetryCount = definition.MaxRetryCount
|
||||
}
|
||||
|
||||
// PublishWorkflowSnapshot keeps the Agent settings and its referenced
|
||||
// workflow definition together as an immutable, reproducible revision.
|
||||
func (s *agentRevisionService) PublishWorkflowSnapshot(db *gorm.DB, agent *models.AIAgent, version *models.AIWorkflowVersion, operator *dto.AuthPrincipal) (*models.AgentRevision, error) {
|
||||
return s.publishSnapshot(db, agent, version, operator)
|
||||
}
|
||||
|
||||
func (s *agentRevisionService) PublishSnapshot(db *gorm.DB, agent *models.AIAgent, operator *dto.AuthPrincipal) (*models.AgentRevision, error) {
|
||||
return s.publishSnapshot(db, agent, nil, operator)
|
||||
}
|
||||
|
||||
func (s *agentRevisionService) publishSnapshot(db *gorm.DB, agent *models.AIAgent, version *models.AIWorkflowVersion, operator *dto.AuthPrincipal) (*models.AgentRevision, error) {
|
||||
model := agentRevisionModel{ConfigID: agent.AIConfigID}
|
||||
if config := repositories.AIConfigRepository.Get(db, agent.AIConfigID); config != nil {
|
||||
model = agentRevisionModel{
|
||||
ConfigID: config.ID, Provider: string(config.Provider), BaseURL: config.BaseURL, ModelType: string(config.ModelType),
|
||||
ModelName: config.ModelName, MaxContextTokens: config.MaxContextTokens, MaxOutputTokens: config.MaxOutputTokens,
|
||||
TimeoutMS: config.TimeoutMS, MaxRetryCount: config.MaxRetryCount,
|
||||
}
|
||||
}
|
||||
workflowVersionID := int64(0)
|
||||
workflowDefinition := ""
|
||||
if version != nil {
|
||||
workflowVersionID = version.ID
|
||||
workflowDefinition = version.Definition
|
||||
}
|
||||
definition := agentRevisionDefinition{
|
||||
Agent: agentRevisionAgent{
|
||||
Name: agent.Name, Description: agent.Description, AIConfigID: agent.AIConfigID,
|
||||
RuntimeMode: string(agent.RuntimeMode), MaxSteps: agent.MaxSteps, ContextWindow: agent.ContextWindow,
|
||||
ToolPolicy: agent.ToolPolicy, KnowledgePolicy: agent.KnowledgePolicy, ServiceMode: int(agent.ServiceMode), SystemPrompt: agent.SystemPrompt,
|
||||
WelcomeMessage: agent.WelcomeMessage, ReplyTimeoutSeconds: agent.ReplyTimeoutSeconds, TeamIDs: agent.TeamIDs, HandoffMode: int(agent.HandoffMode),
|
||||
FallbackMode: int(agent.FallbackMode), FallbackMessage: agent.FallbackMessage, KnowledgeIDs: agent.KnowledgeIDs,
|
||||
SkillIDs: agent.SkillIDs, AllowedMCPTools: agent.AllowedMCPTools,
|
||||
},
|
||||
Model: model,
|
||||
WorkflowVersionID: workflowVersionID,
|
||||
WorkflowDefinition: workflowDefinition,
|
||||
}
|
||||
data, err := json.Marshal(definition)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
now := time.Now()
|
||||
hash := sha256.Sum256(data)
|
||||
item := &models.AgentRevision{
|
||||
AgentID: agent.ID, Revision: repositories.AgentRevisionRepository.MaxRevisionByAgentID(db, agent.ID) + 1,
|
||||
WorkflowVersionID: workflowVersionID, Status: enums.StatusOk, Definition: string(data), DefinitionHash: hex.EncodeToString(hash[:]),
|
||||
PublishedAt: &now, PublishedByID: operator.UserID, PublishedByName: operator.Username, AuditFields: utils.BuildAuditFields(operator),
|
||||
}
|
||||
if err := repositories.AgentRevisionRepository.Create(db, item); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return item, nil
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"agent-desk/internal/models"
|
||||
"agent-desk/internal/pkg/enums"
|
||||
|
||||
"github.com/glebarez/sqlite"
|
||||
"github.com/mlogclub/simple/sqls"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
func TestAgentRevisionServiceRestoresPublishedSnapshotAndKeepsAPIKey(t *testing.T) {
|
||||
db, err := gorm.Open(sqlite.Open("file:"+strings.ReplaceAll(t.Name(), "/", "_")+"?mode=memory&cache=shared"), &gorm.Config{})
|
||||
if err != nil {
|
||||
t.Fatalf("open sqlite: %v", err)
|
||||
}
|
||||
if err := db.AutoMigrate(&models.AgentRevision{}); err != nil {
|
||||
t.Fatalf("auto migrate: %v", err)
|
||||
}
|
||||
sqls.SetDB(db)
|
||||
definition := agentRevisionDefinition{
|
||||
Agent: agentRevisionAgent{
|
||||
Name: "published agent", AIConfigID: 8, RuntimeMode: string(enums.AIAgentRuntimeModeAutonomous),
|
||||
MaxSteps: 5, ContextWindow: 9, SystemPrompt: "published instruction", KnowledgeIDs: "4", ReplyTimeoutSeconds: 90,
|
||||
},
|
||||
Model: agentRevisionModel{ConfigID: 8, Provider: string(enums.AIProviderOpenAI), BaseURL: "https://published.example/v1", ModelType: string(enums.AIModelTypeLLM), ModelName: "published-model", TimeoutMS: 12000},
|
||||
}
|
||||
data, err := json.Marshal(definition)
|
||||
if err != nil {
|
||||
t.Fatalf("marshal definition: %v", err)
|
||||
}
|
||||
revision := &models.AgentRevision{AgentID: 7, Revision: 1, Status: enums.StatusOk, Definition: string(data)}
|
||||
if err := db.Create(revision).Error; err != nil {
|
||||
t.Fatalf("create revision: %v", err)
|
||||
}
|
||||
snapshot, err := AgentRevisionService.ResolvePublishedSnapshot(models.AIAgent{ID: 7, PublishedRevisionID: revision.ID, SystemPrompt: "draft instruction"}, models.AIConfig{ID: 8, APIKey: "rotated-secret", ModelName: "draft-model"})
|
||||
if err != nil {
|
||||
t.Fatalf("ResolvePublishedSnapshot: %v", err)
|
||||
}
|
||||
if snapshot.Agent.SystemPrompt != "published instruction" || snapshot.Agent.MaxSteps != 5 || snapshot.Agent.ReplyTimeoutSeconds != 90 {
|
||||
t.Fatalf("agent snapshot not restored: %#v", snapshot.Agent)
|
||||
}
|
||||
if snapshot.AIConfig.ModelName != "published-model" || snapshot.AIConfig.BaseURL != "https://published.example/v1" || snapshot.AIConfig.APIKey != "rotated-secret" {
|
||||
t.Fatalf("model snapshot not restored safely: %#v", snapshot.AIConfig)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,514 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
"slices"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"agent-desk/internal/models"
|
||||
"agent-desk/internal/pkg/dto"
|
||||
"agent-desk/internal/pkg/dto/request"
|
||||
"agent-desk/internal/pkg/enums"
|
||||
"agent-desk/internal/pkg/errorsx"
|
||||
"agent-desk/internal/pkg/httpx/params"
|
||||
"agent-desk/internal/pkg/utils"
|
||||
"agent-desk/internal/repositories"
|
||||
|
||||
"github.com/mlogclub/simple/sqls"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
var AgentRunService = newAgentRunService()
|
||||
|
||||
func newAgentRunService() *agentRunService {
|
||||
return &agentRunService{}
|
||||
}
|
||||
|
||||
type agentRunService struct{}
|
||||
|
||||
type AgentRunMetrics struct {
|
||||
TotalRuns int `json:"totalRuns"`
|
||||
CompletedRuns int `json:"completedRuns"`
|
||||
FailedRuns int `json:"failedRuns"`
|
||||
InterruptedRuns int `json:"interruptedRuns"`
|
||||
CompletionRate float64 `json:"completionRate"`
|
||||
ToolCalls int `json:"toolCalls"`
|
||||
ToolSuccessRate float64 `json:"toolSuccessRate"`
|
||||
AverageSteps float64 `json:"averageSteps"`
|
||||
AverageDurationMS int64 `json:"averageDurationMs"`
|
||||
P95DurationMS int64 `json:"p95DurationMs"`
|
||||
PromptTokens int64 `json:"promptTokens"`
|
||||
CompletionTokens int64 `json:"completionTokens"`
|
||||
HandoffRate float64 `json:"handoffRate"`
|
||||
KnowledgeFallbackRate float64 `json:"knowledgeFallbackRate"`
|
||||
ResumedInterrupts int `json:"resumedInterrupts"`
|
||||
ResolvedInterrupts int `json:"resolvedInterrupts"`
|
||||
InterruptRecoveryRate float64 `json:"interruptRecoveryRate"`
|
||||
ReviewedRuns int `json:"reviewedRuns"`
|
||||
ResolvedRuns int `json:"resolvedRuns"`
|
||||
ResolutionRate float64 `json:"resolutionRate"`
|
||||
UnsupportedEvidenceRuns int `json:"unsupportedEvidenceRuns"`
|
||||
UnsupportedEvidenceRate float64 `json:"unsupportedEvidenceRate"`
|
||||
}
|
||||
|
||||
type AgentRunEngineComparison struct {
|
||||
EngineCode string `json:"engineCode"`
|
||||
Metrics AgentRunMetrics `json:"metrics"`
|
||||
}
|
||||
|
||||
const maxAgentAuditPreviewChars = 4000
|
||||
|
||||
var agentAuditSecretPattern = regexp.MustCompile(`(?i)(?:"|')?(api[_-]?key|authorization|password|secret|token|cookie)(?:"|')?\s*([:=])\s*(?:"[^"]*"|'[^']*'|[^\s,;}]+)`)
|
||||
|
||||
func (s *agentRunService) Get(id int64) *models.AgentRun {
|
||||
if id <= 0 {
|
||||
return nil
|
||||
}
|
||||
return repositories.AgentRunRepository.Get(sqls.DB(), id)
|
||||
}
|
||||
|
||||
func (s *agentRunService) FindPageByParams(queryParams *params.QueryParams) (list []models.AgentRun, paging *sqls.Paging) {
|
||||
return repositories.AgentRunRepository.FindPageByParams(sqls.DB(), queryParams)
|
||||
}
|
||||
|
||||
func (s *agentRunService) GetDetail(id int64) (*models.AgentRun, []models.AgentStep, []models.AgentToolCall) {
|
||||
run := s.Get(id)
|
||||
if run == nil {
|
||||
return nil, nil, nil
|
||||
}
|
||||
return run,
|
||||
repositories.AgentStepRepository.FindByAgentRunID(sqls.DB(), id),
|
||||
repositories.AgentToolCallRepository.FindByAgentRunID(sqls.DB(), id)
|
||||
}
|
||||
|
||||
func (s *agentRunService) GetLatestStepID(agentRunID int64) int64 {
|
||||
step := repositories.AgentStepRepository.LastByAgentRunID(sqls.DB(), agentRunID)
|
||||
if step == nil {
|
||||
return 0
|
||||
}
|
||||
return step.ID
|
||||
}
|
||||
|
||||
func (s *agentRunService) GetQualityFeedback(agentRunID int64) *models.AgentRunQualityFeedback {
|
||||
return repositories.AgentRunQualityFeedbackRepository.GetByAgentRunID(sqls.DB(), agentRunID)
|
||||
}
|
||||
|
||||
func (s *agentRunService) SaveQualityFeedback(req request.SaveAgentRunQualityFeedbackRequest, operator *dto.AuthPrincipal) error {
|
||||
if operator == nil {
|
||||
return errorsx.UnauthorizedI18n("error.auth.expired")
|
||||
}
|
||||
if req.AgentRunID <= 0 {
|
||||
return errorsx.InvalidParam("agent run id is required")
|
||||
}
|
||||
if !slices.Contains(enums.AgentRunResolutionStatusValues, req.ResolutionStatus) || !slices.Contains(enums.AgentRunEvidenceStatusValues, req.EvidenceStatus) {
|
||||
return errorsx.InvalidParam("invalid agent run quality feedback status")
|
||||
}
|
||||
comment := strings.TrimSpace(req.Comment)
|
||||
if len([]rune(comment)) > 2000 {
|
||||
return errorsx.InvalidParam("agent run quality feedback comment is too long")
|
||||
}
|
||||
return sqls.WithTransaction(func(ctx *sqls.TxContext) error {
|
||||
if repositories.AgentRunRepository.Get(ctx.Tx, req.AgentRunID) == nil {
|
||||
return errorsx.InvalidParam("agent run does not exist")
|
||||
}
|
||||
current := repositories.AgentRunQualityFeedbackRepository.GetByAgentRunID(ctx.Tx, req.AgentRunID)
|
||||
if current == nil {
|
||||
return repositories.AgentRunQualityFeedbackRepository.Create(ctx.Tx, &models.AgentRunQualityFeedback{
|
||||
AgentRunID: req.AgentRunID, ResolutionStatus: req.ResolutionStatus, EvidenceStatus: req.EvidenceStatus, Comment: comment,
|
||||
AuditFields: utils.BuildAuditFields(operator),
|
||||
})
|
||||
}
|
||||
return repositories.AgentRunQualityFeedbackRepository.Updates(ctx.Tx, current.ID, map[string]any{
|
||||
"resolution_status": req.ResolutionStatus,
|
||||
"evidence_status": req.EvidenceStatus,
|
||||
"comment": comment,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": time.Now(),
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
// GetMetrics aggregates normalized audit records in Go so SQLite and MySQL
|
||||
// use identical percentile and rate semantics.
|
||||
func (s *agentRunService) GetMetrics(aiAgentID int64) AgentRunMetrics {
|
||||
runs := repositories.AgentRunRepository.FindRecent(sqls.DB(), aiAgentID, 5000)
|
||||
metrics := s.aggregateMetrics(sqls.DB(), runs)
|
||||
if len(runs) == 0 {
|
||||
return metrics
|
||||
}
|
||||
conversationCount := repositories.ConversationRepository.CountByAIAgentID(sqls.DB(), aiAgentID)
|
||||
if conversationCount > 0 {
|
||||
metrics.HandoffRate = float64(repositories.ConversationRepository.CountHandoffByAIAgentID(sqls.DB(), aiAgentID)) / float64(conversationCount)
|
||||
}
|
||||
return metrics
|
||||
}
|
||||
|
||||
// GetEngineComparisons keeps Workflow, Autonomous, and Hybrid reports based on
|
||||
// the same normalized audit and reviewed-quality records. Conversation-level
|
||||
// handoff is deliberately excluded because it cannot be attributed to one
|
||||
// Engine after a mode change.
|
||||
func (s *agentRunService) GetEngineComparisons(aiAgentID int64) []AgentRunEngineComparison {
|
||||
runs := repositories.AgentRunRepository.FindRecent(sqls.DB(), aiAgentID, 5000)
|
||||
groups := make(map[string][]models.AgentRun)
|
||||
for _, run := range runs {
|
||||
engineCode := strings.TrimSpace(run.EngineCode)
|
||||
if engineCode == "" {
|
||||
engineCode = "unknown"
|
||||
}
|
||||
groups[engineCode] = append(groups[engineCode], run)
|
||||
}
|
||||
engineCodes := make([]string, 0, len(groups))
|
||||
for engineCode := range groups {
|
||||
engineCodes = append(engineCodes, engineCode)
|
||||
}
|
||||
sort.Strings(engineCodes)
|
||||
ret := make([]AgentRunEngineComparison, 0, len(engineCodes))
|
||||
for _, engineCode := range engineCodes {
|
||||
ret = append(ret, AgentRunEngineComparison{EngineCode: engineCode, Metrics: s.aggregateMetrics(sqls.DB(), groups[engineCode])})
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func (s *agentRunService) aggregateMetrics(db *gorm.DB, runs []models.AgentRun) AgentRunMetrics {
|
||||
metrics := AgentRunMetrics{TotalRuns: len(runs)}
|
||||
if len(runs) == 0 {
|
||||
return metrics
|
||||
}
|
||||
runIDs := make([]int64, 0, len(runs))
|
||||
durations := make([]int64, 0, len(runs))
|
||||
var durationTotal int64
|
||||
for _, run := range runs {
|
||||
runIDs = append(runIDs, run.ID)
|
||||
switch run.Status {
|
||||
case "completed":
|
||||
metrics.CompletedRuns++
|
||||
case "failed":
|
||||
metrics.FailedRuns++
|
||||
case "interrupted":
|
||||
metrics.InterruptedRuns++
|
||||
}
|
||||
metrics.PromptTokens += int64(run.PromptTokens)
|
||||
metrics.CompletionTokens += int64(run.CompletionTokens)
|
||||
if run.EndedAt != nil {
|
||||
duration := run.EndedAt.Sub(run.StartedAt).Milliseconds()
|
||||
if duration < 0 {
|
||||
duration = 0
|
||||
}
|
||||
durations = append(durations, duration)
|
||||
durationTotal += duration
|
||||
}
|
||||
}
|
||||
metrics.CompletionRate = float64(metrics.CompletedRuns) / float64(metrics.TotalRuns)
|
||||
if len(durations) > 0 {
|
||||
metrics.AverageDurationMS = durationTotal / int64(len(durations))
|
||||
sort.Slice(durations, func(i, j int) bool { return durations[i] < durations[j] })
|
||||
index := (len(durations)*95+99)/100 - 1
|
||||
metrics.P95DurationMS = durations[index]
|
||||
}
|
||||
steps := repositories.AgentStepRepository.FindByAgentRunIDs(db, runIDs)
|
||||
metrics.AverageSteps = float64(len(steps)) / float64(metrics.TotalRuns)
|
||||
fallbackRunIDs := make(map[int64]struct{})
|
||||
for _, step := range steps {
|
||||
if step.StepType == "policy" && step.StepCode == "knowledge_evidence" {
|
||||
fallbackRunIDs[step.AgentRunID] = struct{}{}
|
||||
}
|
||||
}
|
||||
metrics.KnowledgeFallbackRate = float64(len(fallbackRunIDs)) / float64(metrics.TotalRuns)
|
||||
toolCalls := repositories.AgentToolCallRepository.FindByAgentRunIDs(db, runIDs)
|
||||
metrics.ToolCalls = len(toolCalls)
|
||||
if len(toolCalls) > 0 {
|
||||
completed := 0
|
||||
for _, call := range toolCalls {
|
||||
if call.Status == "completed" {
|
||||
completed++
|
||||
}
|
||||
}
|
||||
metrics.ToolSuccessRate = float64(completed) / float64(len(toolCalls))
|
||||
}
|
||||
interrupts := repositories.ConversationInterruptRepository.FindByAgentRunIDs(db, runIDs)
|
||||
for _, interrupt := range interrupts {
|
||||
if interrupt.ResumeCount <= 0 {
|
||||
continue
|
||||
}
|
||||
metrics.ResumedInterrupts++
|
||||
if interrupt.Status == "resolved" {
|
||||
metrics.ResolvedInterrupts++
|
||||
}
|
||||
}
|
||||
if metrics.ResumedInterrupts > 0 {
|
||||
metrics.InterruptRecoveryRate = float64(metrics.ResolvedInterrupts) / float64(metrics.ResumedInterrupts)
|
||||
}
|
||||
feedbacks := repositories.AgentRunQualityFeedbackRepository.FindByAgentRunIDs(db, runIDs)
|
||||
metrics.ReviewedRuns = len(feedbacks)
|
||||
for _, feedback := range feedbacks {
|
||||
if feedback.ResolutionStatus == enums.AgentRunResolutionStatusResolved {
|
||||
metrics.ResolvedRuns++
|
||||
}
|
||||
if feedback.EvidenceStatus == enums.AgentRunEvidenceStatusUnsupported {
|
||||
metrics.UnsupportedEvidenceRuns++
|
||||
}
|
||||
}
|
||||
if metrics.ReviewedRuns > 0 {
|
||||
metrics.ResolutionRate = float64(metrics.ResolvedRuns) / float64(metrics.ReviewedRuns)
|
||||
metrics.UnsupportedEvidenceRate = float64(metrics.UnsupportedEvidenceRuns) / float64(metrics.ReviewedRuns)
|
||||
}
|
||||
return metrics
|
||||
}
|
||||
|
||||
type WorkflowAgentRunInput struct {
|
||||
WorkflowRunID int64
|
||||
WorkflowVersionID int64
|
||||
ConversationID int64
|
||||
AIAgentID int64
|
||||
SourceMessageID int64
|
||||
Status string
|
||||
PromptTokens int
|
||||
CompletionTokens int
|
||||
StartedAt time.Time
|
||||
EndedAt *time.Time
|
||||
ErrorMessage string
|
||||
TraceData string
|
||||
StepInputPreview string
|
||||
StepOutputPreview string
|
||||
}
|
||||
|
||||
type EngineAgentRunInput struct {
|
||||
ConversationID int64
|
||||
AIAgentID int64
|
||||
AgentRevisionID int64
|
||||
SourceMessageID int64
|
||||
EngineCode string
|
||||
Status string
|
||||
PromptTokens int
|
||||
CompletionTokens int
|
||||
StartedAt time.Time
|
||||
EndedAt *time.Time
|
||||
ErrorMessage string
|
||||
TraceData string
|
||||
StepType string
|
||||
StepCode string
|
||||
StepInputPreview string
|
||||
StepOutputPreview string
|
||||
AdditionalSteps []EngineStepInput
|
||||
ToolCalls []EngineToolCallInput
|
||||
}
|
||||
|
||||
type EngineStepInput struct {
|
||||
StepType string
|
||||
StepCode string
|
||||
WorkflowRunID int64
|
||||
Status string
|
||||
InputPreview string
|
||||
OutputPreview string
|
||||
ErrorMessage string
|
||||
}
|
||||
|
||||
type EngineToolCallInput struct {
|
||||
ToolCode string
|
||||
RiskLevel string
|
||||
RequireConfirm bool
|
||||
Status string
|
||||
ArgumentsPreview string
|
||||
ResultPreview string
|
||||
ErrorMessage string
|
||||
DurationMS int
|
||||
}
|
||||
|
||||
// RecordHybridPlaybookResume closes or re-interrupts the Hybrid AgentRun that
|
||||
// originally selected a Playbook. The detailed WorkflowRun remains separately
|
||||
// auditable; this step preserves the parent AgentRun -> AgentStep -> WorkflowRun
|
||||
// relationship across a human confirmation pause.
|
||||
func (s *agentRunService) RecordHybridPlaybookResume(db *gorm.DB, agentRunID, workflowRunID int64, status, replyText string) error {
|
||||
if agentRunID <= 0 {
|
||||
return nil
|
||||
}
|
||||
run := repositories.AgentRunRepository.Get(db, agentRunID)
|
||||
if run == nil || run.EngineCode != "hybrid" {
|
||||
return nil
|
||||
}
|
||||
status = strings.TrimSpace(status)
|
||||
if status == "" {
|
||||
status = "completed"
|
||||
}
|
||||
now := time.Now()
|
||||
durationMS := int(now.Sub(run.StartedAt).Milliseconds())
|
||||
if durationMS < 0 {
|
||||
durationMS = 0
|
||||
}
|
||||
if err := repositories.AgentRunRepository.Updates(db, run.ID, map[string]any{
|
||||
"status": status,
|
||||
"ended_at": &now,
|
||||
"error_message": "",
|
||||
"updated_at": now,
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
return repositories.AgentStepRepository.Create(db, &models.AgentStep{
|
||||
AgentRunID: run.ID, WorkflowRunID: workflowRunID,
|
||||
StepType: "playbook", StepCode: "playbook_resume", Status: status,
|
||||
InputPreview: "human confirmation resume",
|
||||
OutputPreview: sanitizeAgentAuditPreview(replyText),
|
||||
StartedAt: now, EndedAt: &now, DurationMS: durationMS, CreatedAt: now,
|
||||
})
|
||||
}
|
||||
|
||||
// RecordEngineRun writes a non-workflow Engine audit run and its normalized
|
||||
// root step in one transaction owned by the caller.
|
||||
func (s *agentRunService) RecordEngineRun(db *gorm.DB, input EngineAgentRunInput) (int64, error) {
|
||||
now := time.Now()
|
||||
startedAt := input.StartedAt
|
||||
if startedAt.IsZero() {
|
||||
startedAt = now
|
||||
}
|
||||
status := strings.TrimSpace(input.Status)
|
||||
if status == "" {
|
||||
status = "completed"
|
||||
}
|
||||
run := &models.AgentRun{
|
||||
ConversationID: input.ConversationID, AIAgentID: input.AIAgentID, AgentRevisionID: input.AgentRevisionID,
|
||||
SourceMessageID: input.SourceMessageID, EngineCode: strings.TrimSpace(input.EngineCode), Status: status,
|
||||
PromptTokens: input.PromptTokens, CompletionTokens: input.CompletionTokens, StartedAt: startedAt, EndedAt: input.EndedAt,
|
||||
ErrorMessage: sanitizeAgentAuditPreview(input.ErrorMessage), TraceData: sanitizeAgentAuditPreview(input.TraceData), CreatedAt: now, UpdatedAt: now,
|
||||
}
|
||||
if err := repositories.AgentRunRepository.Create(db, run); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
durationMS := 0
|
||||
if input.EndedAt != nil {
|
||||
durationMS = int(input.EndedAt.Sub(startedAt).Milliseconds())
|
||||
if durationMS < 0 {
|
||||
durationMS = 0
|
||||
}
|
||||
}
|
||||
step := &models.AgentStep{
|
||||
AgentRunID: run.ID, StepType: strings.TrimSpace(input.StepType), StepCode: strings.TrimSpace(input.StepCode), Status: status,
|
||||
InputPreview: sanitizeAgentAuditPreview(input.StepInputPreview), OutputPreview: sanitizeAgentAuditPreview(input.StepOutputPreview), ErrorMessage: sanitizeAgentAuditPreview(input.ErrorMessage),
|
||||
StartedAt: startedAt, EndedAt: input.EndedAt, DurationMS: durationMS, CreatedAt: now,
|
||||
}
|
||||
if err := repositories.AgentStepRepository.Create(db, step); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
for _, extra := range input.AdditionalSteps {
|
||||
extraStep := &models.AgentStep{
|
||||
AgentRunID: run.ID, WorkflowRunID: extra.WorkflowRunID, StepType: strings.TrimSpace(extra.StepType), StepCode: strings.TrimSpace(extra.StepCode),
|
||||
Status: firstNonEmptyString(extra.Status, status), InputPreview: sanitizeAgentAuditPreview(extra.InputPreview), OutputPreview: sanitizeAgentAuditPreview(extra.OutputPreview),
|
||||
ErrorMessage: sanitizeAgentAuditPreview(extra.ErrorMessage), StartedAt: startedAt, EndedAt: input.EndedAt, DurationMS: durationMS, CreatedAt: now,
|
||||
}
|
||||
if err := repositories.AgentStepRepository.Create(db, extraStep); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
}
|
||||
for _, call := range input.ToolCalls {
|
||||
toolCall := &models.AgentToolCall{
|
||||
AgentRunID: run.ID, AgentStepID: step.ID, ToolCode: strings.TrimSpace(call.ToolCode), RiskLevel: strings.TrimSpace(call.RiskLevel),
|
||||
RequireConfirm: call.RequireConfirm, Status: firstNonEmptyString(call.Status, status), ArgumentsPreview: sanitizeAgentAuditPreview(call.ArgumentsPreview),
|
||||
ResultPreview: sanitizeAgentAuditPreview(call.ResultPreview), ErrorMessage: sanitizeAgentAuditPreview(call.ErrorMessage), DurationMS: call.DurationMS, CreatedAt: now,
|
||||
}
|
||||
if err := repositories.AgentToolCallRepository.Create(db, toolCall); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
}
|
||||
return run.ID, nil
|
||||
}
|
||||
|
||||
func sanitizeAgentAuditPreview(value string) string {
|
||||
value = strings.TrimSpace(value)
|
||||
if value == "" {
|
||||
return ""
|
||||
}
|
||||
value = agentAuditSecretPattern.ReplaceAllString(value, "$1$2***")
|
||||
runes := []rune(value)
|
||||
if len(runes) <= maxAgentAuditPreviewChars {
|
||||
return value
|
||||
}
|
||||
return strings.TrimSpace(string(runes[:maxAgentAuditPreviewChars])) + "\n[preview truncated]"
|
||||
}
|
||||
|
||||
func firstNonEmptyString(items ...string) string {
|
||||
for _, item := range items {
|
||||
if value := strings.TrimSpace(item); value != "" {
|
||||
return value
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// RecordWorkflowRun writes the Engine-independent audit record inside the
|
||||
// caller's transaction. Workflow-specific tables remain the detailed source
|
||||
// for node-level diagnosis while AgentRun becomes the cross-engine summary.
|
||||
func (s *agentRunService) RecordWorkflowRun(db *gorm.DB, input WorkflowAgentRunInput) (int64, error) {
|
||||
now := time.Now()
|
||||
status := strings.TrimSpace(input.Status)
|
||||
if status == "" {
|
||||
status = "completed"
|
||||
}
|
||||
startedAt := input.StartedAt
|
||||
if startedAt.IsZero() {
|
||||
startedAt = now
|
||||
}
|
||||
run := repositories.AgentRunRepository.TakeByWorkflowRunID(db, input.WorkflowRunID)
|
||||
agentRevisionID := int64(0)
|
||||
if revision := repositories.AgentRevisionRepository.TakeByAgentIDAndWorkflowVersionID(db, input.AIAgentID, input.WorkflowVersionID); revision != nil {
|
||||
agentRevisionID = revision.ID
|
||||
}
|
||||
if run == nil {
|
||||
run = &models.AgentRun{
|
||||
ConversationID: input.ConversationID,
|
||||
AIAgentID: input.AIAgentID,
|
||||
AgentRevisionID: agentRevisionID,
|
||||
SourceMessageID: input.SourceMessageID,
|
||||
WorkflowRunID: input.WorkflowRunID,
|
||||
EngineCode: "workflow",
|
||||
Status: status,
|
||||
PromptTokens: input.PromptTokens,
|
||||
CompletionTokens: input.CompletionTokens,
|
||||
StartedAt: startedAt,
|
||||
EndedAt: input.EndedAt,
|
||||
ErrorMessage: sanitizeAgentAuditPreview(input.ErrorMessage),
|
||||
TraceData: sanitizeAgentAuditPreview(input.TraceData),
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
}
|
||||
if err := repositories.AgentRunRepository.Create(db, run); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
} else if err := repositories.AgentRunRepository.Updates(db, run.ID, map[string]any{
|
||||
"agent_revision_id": agentRevisionID,
|
||||
"status": status,
|
||||
"prompt_tokens": input.PromptTokens,
|
||||
"completion_tokens": input.CompletionTokens,
|
||||
"ended_at": input.EndedAt,
|
||||
"error_message": sanitizeAgentAuditPreview(input.ErrorMessage),
|
||||
"trace_data": sanitizeAgentAuditPreview(input.TraceData),
|
||||
"updated_at": now,
|
||||
}); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
durationMS := 0
|
||||
if input.EndedAt != nil {
|
||||
durationMS = int(input.EndedAt.Sub(startedAt).Milliseconds())
|
||||
if durationMS < 0 {
|
||||
durationMS = 0
|
||||
}
|
||||
}
|
||||
step := &models.AgentStep{
|
||||
AgentRunID: run.ID,
|
||||
StepType: "workflow",
|
||||
StepCode: "workflow",
|
||||
Status: status,
|
||||
InputPreview: sanitizeAgentAuditPreview(input.StepInputPreview),
|
||||
OutputPreview: sanitizeAgentAuditPreview(input.StepOutputPreview),
|
||||
ErrorMessage: sanitizeAgentAuditPreview(input.ErrorMessage),
|
||||
StartedAt: startedAt,
|
||||
EndedAt: input.EndedAt,
|
||||
DurationMS: durationMS,
|
||||
CreatedAt: now,
|
||||
}
|
||||
if err := repositories.AgentStepRepository.Create(db, step); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return run.ID, nil
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"agent-desk/internal/models"
|
||||
"agent-desk/internal/pkg/dto"
|
||||
"agent-desk/internal/pkg/dto/request"
|
||||
"agent-desk/internal/pkg/enums"
|
||||
"agent-desk/internal/pkg/httpx/params"
|
||||
"agent-desk/internal/repositories"
|
||||
|
||||
"github.com/glebarez/sqlite"
|
||||
"github.com/mlogclub/simple/sqls"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/schema"
|
||||
)
|
||||
|
||||
func TestAgentRunServiceFindsWorkflowAuditDetail(t *testing.T) {
|
||||
db := setupAgentRunServiceTestDB(t)
|
||||
now := time.Now()
|
||||
endedAt := now.Add(time.Second)
|
||||
run := &models.AgentRun{
|
||||
ConversationID: 11,
|
||||
AIAgentID: 12,
|
||||
WorkflowRunID: 13,
|
||||
EngineCode: "workflow",
|
||||
Status: "completed",
|
||||
StartedAt: now,
|
||||
EndedAt: &endedAt,
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
}
|
||||
if err := db.Create(run).Error; err != nil {
|
||||
t.Fatalf("create agent run: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.AgentStep{AgentRunID: run.ID, StepType: "workflow", Status: "completed", StartedAt: now, EndedAt: &endedAt, CreatedAt: now}).Error; err != nil {
|
||||
t.Fatalf("create agent step: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.AgentToolCall{AgentRunID: run.ID, ToolCode: "knowledge.retrieve", Status: "completed", CreatedAt: now}).Error; err != nil {
|
||||
t.Fatalf("create tool call: %v", err)
|
||||
}
|
||||
|
||||
cnd := sqls.NewCnd().Eq("conversation_id", run.ConversationID).Desc("id").Page(1, 20)
|
||||
queryParams := ¶ms.QueryParams{Cnd: *cnd}
|
||||
list, paging := AgentRunService.FindPageByParams(queryParams)
|
||||
if len(list) != 1 || paging.Total != 1 || list[0].ID != run.ID {
|
||||
t.Fatalf("unexpected agent run page: list=%#v paging=%#v", list, paging)
|
||||
}
|
||||
item, steps, toolCalls := AgentRunService.GetDetail(run.ID)
|
||||
if item == nil || len(steps) != 1 || len(toolCalls) != 1 {
|
||||
t.Fatalf("unexpected agent run detail: run=%#v steps=%#v toolCalls=%#v", item, steps, toolCalls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAgentRunServiceAssociatesWorkflowRevision(t *testing.T) {
|
||||
db := setupAgentRunServiceTestDB(t)
|
||||
now := time.Now()
|
||||
if err := db.Create(&models.AgentRevision{AgentID: 12, Revision: 1, WorkflowVersionID: 14}).Error; err != nil {
|
||||
t.Fatalf("create agent revision: %v", err)
|
||||
}
|
||||
if _, err := AgentRunService.RecordWorkflowRun(db, WorkflowAgentRunInput{
|
||||
WorkflowRunID: 13, WorkflowVersionID: 14, ConversationID: 11, AIAgentID: 12,
|
||||
Status: "completed", StartedAt: now,
|
||||
}); err != nil {
|
||||
t.Fatalf("RecordWorkflowRun returned error: %v", err)
|
||||
}
|
||||
run := repositories.AgentRunRepository.TakeByWorkflowRunID(db, 13)
|
||||
if run == nil || run.AgentRevisionID <= 0 {
|
||||
t.Fatalf("expected AgentRun to link revision, got %#v", run)
|
||||
}
|
||||
if stepID := AgentRunService.GetLatestStepID(run.ID); stepID <= 0 {
|
||||
t.Fatalf("expected normalized agent step id, got %d", stepID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAgentRunServiceRecordsEngineToolCall(t *testing.T) {
|
||||
db := setupAgentRunServiceTestDB(t)
|
||||
now := time.Now()
|
||||
runID, err := AgentRunService.RecordEngineRun(db, EngineAgentRunInput{
|
||||
ConversationID: 1, AIAgentID: 2, AgentRevisionID: 3, EngineCode: "autonomous", Status: "completed", StartedAt: now,
|
||||
StepType: "model", StepCode: "chat_completion", StepInputPreview: "authorization=Bearer-secret", ToolCalls: []EngineToolCallInput{{
|
||||
ToolCode: "knowledge/search", RiskLevel: "read", Status: "completed", ArgumentsPreview: `{"token":"abc123","query":"refund"}`, ResultPreview: "policy text",
|
||||
}},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("RecordEngineRun returned error: %v", err)
|
||||
}
|
||||
_, steps, toolCalls := AgentRunService.GetDetail(runID)
|
||||
if len(toolCalls) != 1 || toolCalls[0].ToolCode != "knowledge/search" || toolCalls[0].AgentStepID <= 0 {
|
||||
t.Fatalf("unexpected tool audit: %#v", toolCalls)
|
||||
}
|
||||
if strings.Contains(toolCalls[0].ArgumentsPreview, "abc123") || len(steps) != 1 || strings.Contains(steps[0].InputPreview, "Bearer-secret") {
|
||||
t.Fatalf("sensitive audit data leaked: steps=%#v calls=%#v", steps, toolCalls)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAgentRunServiceRecordsHybridPlaybookResume(t *testing.T) {
|
||||
db := setupAgentRunServiceTestDB(t)
|
||||
now := time.Now().Add(-time.Minute)
|
||||
run := &models.AgentRun{EngineCode: "hybrid", Status: "interrupted", StartedAt: now, CreatedAt: now, UpdatedAt: now}
|
||||
if err := db.Create(run).Error; err != nil {
|
||||
t.Fatalf("create hybrid run: %v", err)
|
||||
}
|
||||
if err := AgentRunService.RecordHybridPlaybookResume(db, run.ID, 33, "completed", "已完成工单登记。"); err != nil {
|
||||
t.Fatalf("RecordHybridPlaybookResume returned error: %v", err)
|
||||
}
|
||||
item, steps, _ := AgentRunService.GetDetail(run.ID)
|
||||
if item == nil || item.Status != "completed" || item.EndedAt == nil {
|
||||
t.Fatalf("expected completed hybrid run, got %#v", item)
|
||||
}
|
||||
if len(steps) != 1 || steps[0].StepCode != "playbook_resume" || steps[0].WorkflowRunID != 33 || steps[0].OutputPreview != "已完成工单登记。" {
|
||||
t.Fatalf("unexpected playbook resume step: %#v", steps)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAgentRunServiceSavesQualityFeedbackPerRun(t *testing.T) {
|
||||
db := setupAgentRunServiceTestDB(t)
|
||||
now := time.Now()
|
||||
run := &models.AgentRun{AIAgentID: 4, EngineCode: "autonomous", Status: "completed", StartedAt: now, CreatedAt: now, UpdatedAt: now}
|
||||
if err := db.Create(run).Error; err != nil {
|
||||
t.Fatalf("create agent run: %v", err)
|
||||
}
|
||||
operator := &dto.AuthPrincipal{UserID: 7, Username: "reviewer"}
|
||||
if err := AgentRunService.SaveQualityFeedback(request.SaveAgentRunQualityFeedbackRequest{
|
||||
AgentRunID: run.ID, ResolutionStatus: enums.AgentRunResolutionStatusResolved, EvidenceStatus: enums.AgentRunEvidenceStatusSupported, Comment: "issue resolved",
|
||||
}, operator); err != nil {
|
||||
t.Fatalf("save quality feedback: %v", err)
|
||||
}
|
||||
if err := AgentRunService.SaveQualityFeedback(request.SaveAgentRunQualityFeedbackRequest{
|
||||
AgentRunID: run.ID, ResolutionStatus: enums.AgentRunResolutionStatusUnresolved, EvidenceStatus: enums.AgentRunEvidenceStatusUnsupported, Comment: "missing evidence",
|
||||
}, operator); err != nil {
|
||||
t.Fatalf("update quality feedback: %v", err)
|
||||
}
|
||||
feedback := AgentRunService.GetQualityFeedback(run.ID)
|
||||
if feedback == nil || feedback.ResolutionStatus != enums.AgentRunResolutionStatusUnresolved || feedback.EvidenceStatus != enums.AgentRunEvidenceStatusUnsupported || feedback.Comment != "missing evidence" || feedback.UpdateUserName != "reviewer" {
|
||||
t.Fatalf("unexpected quality feedback: %#v", feedback)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAgentRunServiceAggregatesCrossEngineMetrics(t *testing.T) {
|
||||
db := setupAgentRunServiceTestDB(t)
|
||||
base := time.Now().Add(-time.Minute)
|
||||
runs := []models.AgentRun{
|
||||
{AIAgentID: 8, EngineCode: "autonomous", Status: "completed", StartedAt: base, EndedAt: timePtr(base.Add(100 * time.Millisecond)), PromptTokens: 10, CompletionTokens: 5, CreatedAt: base, UpdatedAt: base},
|
||||
{AIAgentID: 8, EngineCode: "workflow", Status: "failed", StartedAt: base, EndedAt: timePtr(base.Add(300 * time.Millisecond)), PromptTokens: 8, CompletionTokens: 2, CreatedAt: base, UpdatedAt: base},
|
||||
{AIAgentID: 9, EngineCode: "hybrid", Status: "completed", StartedAt: base, EndedAt: timePtr(base.Add(900 * time.Millisecond)), CreatedAt: base, UpdatedAt: base},
|
||||
}
|
||||
for index := range runs {
|
||||
if err := db.Create(&runs[index]).Error; err != nil {
|
||||
t.Fatalf("create run: %v", err)
|
||||
}
|
||||
}
|
||||
if err := db.Create(&models.AgentStep{AgentRunID: runs[0].ID, Status: "completed", StartedAt: base, CreatedAt: base}).Error; err != nil {
|
||||
t.Fatalf("create step: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.AgentStep{AgentRunID: runs[1].ID, Status: "failed", StartedAt: base, CreatedAt: base}).Error; err != nil {
|
||||
t.Fatalf("create step: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.AgentToolCall{AgentRunID: runs[0].ID, Status: "completed", CreatedAt: base}).Error; err != nil {
|
||||
t.Fatalf("create completed tool call: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.AgentToolCall{AgentRunID: runs[1].ID, Status: "failed", CreatedAt: base}).Error; err != nil {
|
||||
t.Fatalf("create failed tool call: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.Conversation{AIAgentID: 8}).Error; err != nil {
|
||||
t.Fatalf("create conversation: %v", err)
|
||||
}
|
||||
handoffAt := base
|
||||
if err := db.Create(&models.Conversation{AIAgentID: 8, HandoffAt: &handoffAt}).Error; err != nil {
|
||||
t.Fatalf("create handoff conversation: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.ConversationInterrupt{AgentRunID: runs[0].ID, CheckPointID: "metrics-resolved", Status: "resolved", ResumeCount: 1, CreatedAt: base, UpdatedAt: base}).Error; err != nil {
|
||||
t.Fatalf("create resolved interrupt: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.ConversationInterrupt{AgentRunID: runs[1].ID, CheckPointID: "metrics-cancelled", Status: "cancelled", ResumeCount: 1, CreatedAt: base, UpdatedAt: base}).Error; err != nil {
|
||||
t.Fatalf("create cancelled interrupt: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.AgentRunQualityFeedback{AgentRunID: runs[0].ID, ResolutionStatus: enums.AgentRunResolutionStatusResolved, EvidenceStatus: enums.AgentRunEvidenceStatusSupported}).Error; err != nil {
|
||||
t.Fatalf("create resolved feedback: %v", err)
|
||||
}
|
||||
if err := db.Create(&models.AgentRunQualityFeedback{AgentRunID: runs[1].ID, ResolutionStatus: enums.AgentRunResolutionStatusUnresolved, EvidenceStatus: enums.AgentRunEvidenceStatusUnsupported}).Error; err != nil {
|
||||
t.Fatalf("create unresolved feedback: %v", err)
|
||||
}
|
||||
metrics := AgentRunService.GetMetrics(8)
|
||||
if metrics.TotalRuns != 2 || metrics.CompletedRuns != 1 || metrics.FailedRuns != 1 || metrics.CompletionRate != 0.5 {
|
||||
t.Fatalf("unexpected run metrics: %#v", metrics)
|
||||
}
|
||||
if metrics.AverageDurationMS != 200 || metrics.P95DurationMS != 300 || metrics.ToolCalls != 2 || metrics.ToolSuccessRate != 0.5 || metrics.AverageSteps != 1 {
|
||||
t.Fatalf("unexpected aggregate metrics: %#v", metrics)
|
||||
}
|
||||
if metrics.PromptTokens != 18 || metrics.CompletionTokens != 7 {
|
||||
t.Fatalf("unexpected token metrics: %#v", metrics)
|
||||
}
|
||||
if metrics.HandoffRate != 0.5 || metrics.KnowledgeFallbackRate != 0 {
|
||||
t.Fatalf("unexpected business metrics: %#v", metrics)
|
||||
}
|
||||
if metrics.ResumedInterrupts != 2 || metrics.ResolvedInterrupts != 1 || metrics.InterruptRecoveryRate != 0.5 {
|
||||
t.Fatalf("unexpected interrupt recovery metrics: %#v", metrics)
|
||||
}
|
||||
if metrics.ReviewedRuns != 2 || metrics.ResolvedRuns != 1 || metrics.ResolutionRate != 0.5 || metrics.UnsupportedEvidenceRuns != 1 || metrics.UnsupportedEvidenceRate != 0.5 {
|
||||
t.Fatalf("unexpected quality metrics: %#v", metrics)
|
||||
}
|
||||
comparisons := AgentRunService.GetEngineComparisons(8)
|
||||
if len(comparisons) != 2 || comparisons[0].EngineCode != "autonomous" || comparisons[1].EngineCode != "workflow" {
|
||||
t.Fatalf("unexpected engine comparison groups: %#v", comparisons)
|
||||
}
|
||||
if comparisons[0].Metrics.TotalRuns != 1 || comparisons[0].Metrics.ResolutionRate != 1 || comparisons[1].Metrics.TotalRuns != 1 || comparisons[1].Metrics.UnsupportedEvidenceRate != 1 {
|
||||
t.Fatalf("unexpected engine comparison metrics: %#v", comparisons)
|
||||
}
|
||||
}
|
||||
|
||||
func timePtr(value time.Time) *time.Time { return &value }
|
||||
|
||||
func setupAgentRunServiceTestDB(t *testing.T) *gorm.DB {
|
||||
t.Helper()
|
||||
dbName := strings.NewReplacer("/", "_", " ", "_").Replace(t.Name())
|
||||
db, err := gorm.Open(sqlite.Open("file:"+dbName+"?mode=memory&cache=shared"), &gorm.Config{
|
||||
NamingStrategy: schema.NamingStrategy{TablePrefix: "t_", SingularTable: true},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("open sqlite: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
sqlDB, err := db.DB()
|
||||
if err == nil {
|
||||
_ = sqlDB.Close()
|
||||
}
|
||||
})
|
||||
if err := db.AutoMigrate(&models.AgentRevision{}, &models.AgentRun{}, &models.AgentStep{}, &models.AgentToolCall{}, &models.AgentRunQualityFeedback{}, &models.Conversation{}, &models.ConversationInterrupt{}); err != nil {
|
||||
t.Fatalf("auto migrate: %v", err)
|
||||
}
|
||||
sqls.SetDB(db)
|
||||
return db
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"agent-desk/internal/models"
|
||||
"agent-desk/internal/repositories"
|
||||
|
||||
"github.com/mlogclub/simple/sqls"
|
||||
)
|
||||
|
||||
const (
|
||||
agentToolInvocationStatusRunning = "running"
|
||||
agentToolInvocationStatusCompleted = "completed"
|
||||
agentToolInvocationStatusFailed = "failed"
|
||||
)
|
||||
|
||||
var AgentToolInvocationService = newAgentToolInvocationService()
|
||||
|
||||
type AgentToolInvocationClaim struct {
|
||||
Item *models.AgentToolInvocation
|
||||
Completed bool
|
||||
Acquired bool
|
||||
}
|
||||
|
||||
type agentToolInvocationService struct{}
|
||||
|
||||
func newAgentToolInvocationService() *agentToolInvocationService {
|
||||
return &agentToolInvocationService{}
|
||||
}
|
||||
|
||||
// Claim obtains the persistent idempotency boundary. A completed invocation
|
||||
// can be returned to callers; an in-flight invocation is never executed again.
|
||||
func (s *agentToolInvocationService) Claim(conversationID, aiAgentID int64, toolCode, idempotencyKey string) (*AgentToolInvocationClaim, error) {
|
||||
toolCode = strings.TrimSpace(toolCode)
|
||||
idempotencyKey = strings.TrimSpace(idempotencyKey)
|
||||
if conversationID <= 0 || toolCode == "" || idempotencyKey == "" {
|
||||
return nil, nil
|
||||
}
|
||||
if item := repositories.AgentToolInvocationRepository.GetByIdempotencyKey(sqls.DB(), conversationID, toolCode, idempotencyKey); item != nil {
|
||||
if item.Status == agentToolInvocationStatusCompleted {
|
||||
return &AgentToolInvocationClaim{Item: item, Completed: true}, nil
|
||||
}
|
||||
if item.Status == agentToolInvocationStatusRunning {
|
||||
return &AgentToolInvocationClaim{Item: item}, nil
|
||||
}
|
||||
if err := repositories.AgentToolInvocationRepository.Updates(sqls.DB(), item.ID, map[string]any{"status": agentToolInvocationStatusRunning, "error_message": "", "updated_at": time.Now()}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
item.Status, item.ErrorMessage = agentToolInvocationStatusRunning, ""
|
||||
return &AgentToolInvocationClaim{Item: item, Acquired: true}, nil
|
||||
}
|
||||
item := &models.AgentToolInvocation{ConversationID: conversationID, AIAgentID: aiAgentID, ToolCode: toolCode, IdempotencyKey: idempotencyKey, Status: agentToolInvocationStatusRunning}
|
||||
if err := repositories.AgentToolInvocationRepository.Create(sqls.DB(), item); err != nil {
|
||||
// A concurrent caller may have created the unique invocation first.
|
||||
if existing := repositories.AgentToolInvocationRepository.GetByIdempotencyKey(sqls.DB(), conversationID, toolCode, idempotencyKey); existing != nil {
|
||||
return &AgentToolInvocationClaim{Item: existing, Completed: existing.Status == agentToolInvocationStatusCompleted}, nil
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
return &AgentToolInvocationClaim{Item: item, Acquired: true}, nil
|
||||
}
|
||||
|
||||
func (s *agentToolInvocationService) Complete(item *models.AgentToolInvocation, resultData string) error {
|
||||
if item == nil || item.ID <= 0 {
|
||||
return nil
|
||||
}
|
||||
return repositories.AgentToolInvocationRepository.Updates(sqls.DB(), item.ID, map[string]any{"status": agentToolInvocationStatusCompleted, "result_data": resultData, "error_message": "", "updated_at": time.Now()})
|
||||
}
|
||||
|
||||
func (s *agentToolInvocationService) Fail(item *models.AgentToolInvocation, cause error) error {
|
||||
if item == nil || item.ID <= 0 {
|
||||
return nil
|
||||
}
|
||||
message := ""
|
||||
if cause != nil {
|
||||
message = cause.Error()
|
||||
}
|
||||
return repositories.AgentToolInvocationRepository.Updates(sqls.DB(), item.ID, map[string]any{"status": agentToolInvocationStatusFailed, "error_message": message, "updated_at": time.Now()})
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"agent-desk/internal/models"
|
||||
|
||||
"github.com/glebarez/sqlite"
|
||||
"github.com/mlogclub/simple/sqls"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/schema"
|
||||
)
|
||||
|
||||
func TestAgentToolInvocationServiceReusesCompletedInvocation(t *testing.T) {
|
||||
db, err := gorm.Open(sqlite.Open("file:"+strings.ReplaceAll(t.Name(), "/", "_")+"?mode=memory&cache=shared"), &gorm.Config{NamingStrategy: schema.NamingStrategy{TablePrefix: "t_", SingularTable: true}})
|
||||
if err != nil {
|
||||
t.Fatalf("open sqlite: %v", err)
|
||||
}
|
||||
if err := db.AutoMigrate(&models.AgentToolInvocation{}); err != nil {
|
||||
t.Fatalf("auto migrate: %v", err)
|
||||
}
|
||||
sqls.SetDB(db)
|
||||
|
||||
first, err := AgentToolInvocationService.Claim(10, 20, "graph/create_ticket_with_confirmation", "message:30:node:create")
|
||||
if err != nil || first == nil || first.Item == nil || first.Completed {
|
||||
t.Fatalf("first claim = %#v, err=%v", first, err)
|
||||
}
|
||||
if err := AgentToolInvocationService.Complete(first.Item, `{"ticketId":40}`); err != nil {
|
||||
t.Fatalf("complete invocation: %v", err)
|
||||
}
|
||||
second, err := AgentToolInvocationService.Claim(10, 20, "graph/create_ticket_with_confirmation", "message:30:node:create")
|
||||
if err != nil || second == nil || !second.Completed || second.Item.ResultData != `{"ticketId":40}` {
|
||||
t.Fatalf("second claim = %#v, err=%v", second, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAgentToolInvocationServiceAllowsFailedInvocationRetry(t *testing.T) {
|
||||
db, err := gorm.Open(sqlite.Open("file:"+strings.ReplaceAll(t.Name(), "/", "_")+"?mode=memory&cache=shared"), &gorm.Config{NamingStrategy: schema.NamingStrategy{TablePrefix: "t_", SingularTable: true}})
|
||||
if err != nil {
|
||||
t.Fatalf("open sqlite: %v", err)
|
||||
}
|
||||
if err := db.AutoMigrate(&models.AgentToolInvocation{}); err != nil {
|
||||
t.Fatalf("auto migrate: %v", err)
|
||||
}
|
||||
sqls.SetDB(db)
|
||||
|
||||
first, err := AgentToolInvocationService.Claim(11, 21, "graph/handoff_to_human", "message:31:node:handoff")
|
||||
if err != nil {
|
||||
t.Fatalf("first claim: %v", err)
|
||||
}
|
||||
if err := AgentToolInvocationService.Fail(first.Item, errTestToolInvocation); err != nil {
|
||||
t.Fatalf("fail invocation: %v", err)
|
||||
}
|
||||
second, err := AgentToolInvocationService.Claim(11, 21, "graph/handoff_to_human", "message:31:node:handoff")
|
||||
if err != nil || second == nil || second.Completed || second.Item.Status != agentToolInvocationStatusRunning || second.Item.ErrorMessage != "" {
|
||||
t.Fatalf("retry claim = %#v, err=%v", second, err)
|
||||
}
|
||||
}
|
||||
|
||||
var errTestToolInvocation = &toolInvocationTestError{}
|
||||
|
||||
type toolInvocationTestError struct{}
|
||||
|
||||
func (e *toolInvocationTestError) Error() string { return "tool failed" }
|
||||
@@ -6,6 +6,7 @@ import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
aitooling "agent-desk/internal/ai/tooling"
|
||||
"agent-desk/internal/models"
|
||||
"agent-desk/internal/pkg/dto"
|
||||
"agent-desk/internal/pkg/dto/request"
|
||||
@@ -18,10 +19,13 @@ import (
|
||||
"agent-desk/internal/pkg/httpx/params"
|
||||
|
||||
"github.com/mlogclub/simple/sqls"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
var AIAgentService = newAIAgentService()
|
||||
|
||||
const defaultNewAutonomousRolloutPercent = 5
|
||||
|
||||
func newAIAgentService() *aIAgentService {
|
||||
return &aIAgentService{}
|
||||
}
|
||||
@@ -79,8 +83,11 @@ func (s *aIAgentService) CreateAIAgent(req request.CreateAIAgentRequest, operato
|
||||
if err := repositories.AIAgentRepository.Create(ctx.Tx, item); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := AIWorkflowService.createDefaultAgentWorkflow(ctx.Tx, item, operator)
|
||||
return err
|
||||
if item.RuntimeMode == enums.AIAgentRuntimeModeWorkflow || item.RuntimeMode == enums.AIAgentRuntimeModeHybrid {
|
||||
_, err := AIWorkflowService.createDefaultAgentWorkflow(ctx.Tx, item, operator)
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -91,31 +98,48 @@ func (s *aIAgentService) UpdateAIAgent(req request.UpdateAIAgentRequest, operato
|
||||
if operator == nil {
|
||||
return errorsx.UnauthorizedI18n("error.auth.expired")
|
||||
}
|
||||
if s.Get(req.ID) == nil {
|
||||
current := s.Get(req.ID)
|
||||
if current == nil {
|
||||
return errorsx.InvalidParamI18n("error.e0002")
|
||||
}
|
||||
item, err := s.buildAIAgentModel(req.ID, req.CreateAIAgentRequest)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return repositories.AIAgentRepository.Updates(sqls.DB(), req.ID, map[string]any{
|
||||
columns := map[string]any{
|
||||
"name": item.Name,
|
||||
"description": item.Description,
|
||||
"ai_config_id": item.AIConfigID,
|
||||
"runtime_mode": item.RuntimeMode,
|
||||
"max_steps": item.MaxSteps,
|
||||
"context_window": item.ContextWindow,
|
||||
"tool_policy": item.ToolPolicy,
|
||||
"knowledge_policy": item.KnowledgePolicy,
|
||||
"service_mode": item.ServiceMode,
|
||||
"system_prompt": item.SystemPrompt,
|
||||
"welcome_message": item.WelcomeMessage,
|
||||
"reply_timeout_seconds": item.ReplyTimeoutSeconds,
|
||||
"rollout_percent": item.RolloutPercent,
|
||||
"team_ids": item.TeamIDs,
|
||||
"handoff_mode": item.HandoffMode,
|
||||
"fallback_mode": item.FallbackMode,
|
||||
"fallback_message": item.FallbackMessage,
|
||||
"knowledge_ids": item.KnowledgeIDs,
|
||||
"skill_ids": item.SkillIDs,
|
||||
"allowed_mcp_tools": item.AllowedMCPTools,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": time.Now(),
|
||||
})
|
||||
}
|
||||
if item.RolloutPercent != current.RolloutPercent {
|
||||
columns["previous_rollout_percent"] = current.RolloutPercent
|
||||
}
|
||||
if current.RuntimeMode == enums.AIAgentRuntimeModeAutonomous || current.RuntimeMode == enums.AIAgentRuntimeModeHybrid || item.RuntimeMode == enums.AIAgentRuntimeModeAutonomous || item.RuntimeMode == enums.AIAgentRuntimeModeHybrid {
|
||||
// Draft edits must not silently change the already published autonomous or hybrid
|
||||
// behavior. The operator must explicitly publish the new revision.
|
||||
columns["published_revision_id"] = 0
|
||||
}
|
||||
return repositories.AIAgentRepository.Updates(sqls.DB(), req.ID, columns)
|
||||
}
|
||||
|
||||
func (s *aIAgentService) DeleteAIAgent(id int64, operator *dto.AuthPrincipal) error {
|
||||
@@ -134,6 +158,133 @@ func (s *aIAgentService) DeleteAIAgent(id int64, operator *dto.AuthPrincipal) er
|
||||
})
|
||||
}
|
||||
|
||||
// PublishAIAgent snapshots a non-workflow Agent before it can receive traffic.
|
||||
func (s *aIAgentService) PublishAIAgent(id int64, operator *dto.AuthPrincipal) (*models.AgentRevision, error) {
|
||||
if operator == nil {
|
||||
return nil, errorsx.UnauthorizedI18n("error.auth.expired")
|
||||
}
|
||||
var revision *models.AgentRevision
|
||||
err := sqls.WithTransaction(func(ctx *sqls.TxContext) error {
|
||||
agent := repositories.AIAgentRepository.Get(ctx.Tx, id)
|
||||
if agent == nil || agent.Status != enums.StatusOk {
|
||||
return errorsx.InvalidParamI18n("error.e0002")
|
||||
}
|
||||
if agent.RuntimeMode == enums.AIAgentRuntimeModeWorkflow || agent.RuntimeMode == enums.AIAgentRuntimeModeHybrid {
|
||||
return errorsx.InvalidParam("workflow and hybrid agents must publish a workflow version")
|
||||
}
|
||||
if err := s.validatePublishableAgent(ctx.Tx, agent); err != nil {
|
||||
return err
|
||||
}
|
||||
var err error
|
||||
revision, err = AgentRevisionService.PublishSnapshot(ctx.Tx, agent, operator)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return repositories.AIAgentRepository.Updates(ctx.Tx, agent.ID, map[string]any{
|
||||
"published_revision_id": revision.ID,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": time.Now(),
|
||||
})
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return revision, nil
|
||||
}
|
||||
|
||||
func (s *aIAgentService) validatePublishableAgent(db *gorm.DB, agent *models.AIAgent) error {
|
||||
if agent == nil || agent.AIConfigID <= 0 {
|
||||
return errorsx.InvalidParam("ai agent model configuration is required before publishing")
|
||||
}
|
||||
config := repositories.AIConfigRepository.Get(db, agent.AIConfigID)
|
||||
if config == nil || config.Status != enums.StatusOk {
|
||||
return errorsx.InvalidParam("ai agent model configuration is unavailable")
|
||||
}
|
||||
if _, err := s.normalizeToolPolicy(agent.ToolPolicy); err != nil {
|
||||
return err
|
||||
}
|
||||
if strings.TrimSpace(agent.AllowedMCPTools) == "" {
|
||||
return nil
|
||||
}
|
||||
var directTools []request.AIAgentMCPToolRequest
|
||||
if err := json.Unmarshal([]byte(agent.AllowedMCPTools), &directTools); err != nil {
|
||||
return errorsx.InvalidParam("ai agent direct tools are invalid")
|
||||
}
|
||||
for _, item := range directTools {
|
||||
definition, err := aitooling.DefaultRegistry.Resolve(item.ToolCode)
|
||||
if err != nil || definition.InputSchema == nil {
|
||||
return errorsx.InvalidParam("ai agent direct tool definition is unavailable")
|
||||
}
|
||||
if definition.RequireConfirmation {
|
||||
return errorsx.InvalidParam("ai agent sensitive direct tools must be executed through a confirmed playbook")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// RollbackAIAgent switches an Agent back to a previously published immutable
|
||||
// revision. It never rewrites the historical snapshot itself.
|
||||
func (s *aIAgentService) RollbackAIAgent(id, revisionID int64, operator *dto.AuthPrincipal) error {
|
||||
if operator == nil {
|
||||
return errorsx.UnauthorizedI18n("error.auth.expired")
|
||||
}
|
||||
if id <= 0 || revisionID <= 0 {
|
||||
return errorsx.InvalidParam("agent id and revision id are required")
|
||||
}
|
||||
return sqls.WithTransaction(func(ctx *sqls.TxContext) error {
|
||||
agent := repositories.AIAgentRepository.Get(ctx.Tx, id)
|
||||
if agent == nil || agent.Status != enums.StatusOk {
|
||||
return errorsx.InvalidParamI18n("error.e0002")
|
||||
}
|
||||
revision := repositories.AgentRevisionRepository.Get(ctx.Tx, revisionID)
|
||||
if revision == nil || revision.AgentID != agent.ID || revision.Status != enums.StatusOk {
|
||||
return errorsx.InvalidParam("agent revision does not exist")
|
||||
}
|
||||
updates := map[string]any{
|
||||
"published_revision_id": revision.ID,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": time.Now(),
|
||||
}
|
||||
if agent.RuntimeMode == enums.AIAgentRuntimeModeWorkflow || agent.RuntimeMode == enums.AIAgentRuntimeModeHybrid {
|
||||
if revision.WorkflowVersionID <= 0 || repositories.AIWorkflowVersionRepository.Get(ctx.Tx, revision.WorkflowVersionID) == nil {
|
||||
return errorsx.InvalidParam("workflow revision does not contain a published workflow version")
|
||||
}
|
||||
updates["workflow_version_id"] = revision.WorkflowVersionID
|
||||
}
|
||||
return repositories.AIAgentRepository.Updates(ctx.Tx, agent.ID, updates)
|
||||
})
|
||||
}
|
||||
|
||||
// RollbackAIAgentRollout restores the prior Agent rollout percentage and
|
||||
// swaps it into history, allowing operators to undo and redo one rollout
|
||||
// change without rewriting an immutable AgentRevision.
|
||||
func (s *aIAgentService) RollbackAIAgentRollout(id int64, operator *dto.AuthPrincipal) error {
|
||||
if operator == nil {
|
||||
return errorsx.UnauthorizedI18n("error.auth.expired")
|
||||
}
|
||||
if id <= 0 {
|
||||
return errorsx.InvalidParam("agent id is required")
|
||||
}
|
||||
return sqls.WithTransaction(func(ctx *sqls.TxContext) error {
|
||||
agent := repositories.AIAgentRepository.Get(ctx.Tx, id)
|
||||
if agent == nil || agent.Status != enums.StatusOk {
|
||||
return errorsx.InvalidParamI18n("error.e0002")
|
||||
}
|
||||
if agent.PreviousRolloutPercent < 1 || agent.PreviousRolloutPercent > 100 {
|
||||
return errorsx.InvalidParam("agent rollout has no previous value to restore")
|
||||
}
|
||||
return repositories.AIAgentRepository.Updates(ctx.Tx, agent.ID, map[string]any{
|
||||
"rollout_percent": agent.PreviousRolloutPercent,
|
||||
"previous_rollout_percent": agent.RolloutPercent,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": time.Now(),
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
func (s *aIAgentService) buildAIAgentModel(id int64, req request.CreateAIAgentRequest) (*models.AIAgent, error) {
|
||||
name := strings.TrimSpace(req.Name)
|
||||
if name == "" {
|
||||
@@ -152,6 +303,28 @@ func (s *aIAgentService) buildAIAgentModel(id int64, req request.CreateAIAgentRe
|
||||
if aiConfig.Status != enums.StatusOk {
|
||||
return nil, errorsx.InvalidParamI18n("error.e0011")
|
||||
}
|
||||
if req.RuntimeMode == "" {
|
||||
req.RuntimeMode = enums.AIAgentRuntimeModeAutonomous
|
||||
}
|
||||
if !enums.IsValidAIAgentRuntimeMode(req.RuntimeMode) {
|
||||
return nil, errorsx.InvalidParam("invalid ai agent runtime mode")
|
||||
}
|
||||
if req.RuntimeMode != enums.AIAgentRuntimeModeWorkflow && req.RuntimeMode != enums.AIAgentRuntimeModeAutonomous && req.RuntimeMode != enums.AIAgentRuntimeModeHybrid {
|
||||
return nil, errorsx.InvalidParam("ai agent runtime mode is not available yet")
|
||||
}
|
||||
if req.MaxSteps == 0 {
|
||||
req.MaxSteps = 6
|
||||
}
|
||||
if req.MaxSteps < 1 || req.MaxSteps > 8 {
|
||||
return nil, errorsx.InvalidParam("ai agent max steps must be between 1 and 8")
|
||||
}
|
||||
if req.ContextWindow < 0 {
|
||||
return nil, errorsx.InvalidParam("ai agent context window must not be negative")
|
||||
}
|
||||
toolPolicy, err := s.normalizeToolPolicy(req.ToolPolicy)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if !slices.Contains(enums.IMConversationServiceModeValues, req.ServiceMode) {
|
||||
return nil, errorsx.InvalidParamI18n("error.e0230")
|
||||
}
|
||||
@@ -175,11 +348,25 @@ func (s *aIAgentService) buildAIAgentModel(id int64, req request.CreateAIAgentRe
|
||||
if req.ReplyTimeoutSeconds < 0 {
|
||||
return nil, errorsx.InvalidParamI18n("error.e0144")
|
||||
}
|
||||
if req.RolloutPercent == 0 {
|
||||
if req.RuntimeMode == enums.AIAgentRuntimeModeAutonomous || req.RuntimeMode == enums.AIAgentRuntimeModeHybrid {
|
||||
req.RolloutPercent = defaultNewAutonomousRolloutPercent
|
||||
} else {
|
||||
req.RolloutPercent = 100
|
||||
}
|
||||
}
|
||||
if req.RolloutPercent < 1 || req.RolloutPercent > 100 {
|
||||
return nil, errorsx.InvalidParam("ai agent rollout percent must be between 1 and 100")
|
||||
}
|
||||
|
||||
skillIDs, err := s.normalizeSkillIDs(req.SkillIDs)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
knowledgeBaseIDs, err := s.normalizeKnowledgeBaseIDs(req.KnowledgeBaseIDs)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
directTools, err := s.normalizeDirectTools(req.DirectTools)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -196,20 +383,93 @@ func (s *aIAgentService) buildAIAgentModel(id int64, req request.CreateAIAgentRe
|
||||
Name: name,
|
||||
Description: strings.TrimSpace(req.Description),
|
||||
AIConfigID: req.AIConfigID,
|
||||
RuntimeMode: req.RuntimeMode,
|
||||
MaxSteps: req.MaxSteps,
|
||||
ContextWindow: req.ContextWindow,
|
||||
ToolPolicy: toolPolicy,
|
||||
KnowledgePolicy: strings.TrimSpace(req.KnowledgePolicy),
|
||||
ServiceMode: req.ServiceMode,
|
||||
SystemPrompt: strings.TrimSpace(req.SystemPrompt),
|
||||
WelcomeMessage: strings.TrimSpace(req.WelcomeMessage),
|
||||
ReplyTimeoutSeconds: req.ReplyTimeoutSeconds,
|
||||
RolloutPercent: req.RolloutPercent,
|
||||
TeamIDs: utils.JoinInt64s(teamIDs),
|
||||
HandoffMode: req.HandoffMode,
|
||||
FallbackMode: req.FallbackMode,
|
||||
FallbackMessage: strings.TrimSpace(req.FallbackMessage),
|
||||
KnowledgeIDs: utils.JoinInt64s(knowledgeBaseIDs),
|
||||
SkillIDs: utils.JoinInt64s(skillIDs),
|
||||
AllowedMCPTools: directToolsJSON,
|
||||
WorkflowVersionID: 0,
|
||||
}, nil
|
||||
}
|
||||
|
||||
type normalizedAIAgentToolPolicy struct {
|
||||
MaxTotalCalls int `json:"maxTotalCalls,omitempty"`
|
||||
MaxArgumentBytes int `json:"maxArgumentBytes,omitempty"`
|
||||
AllowedRiskLevels []string `json:"allowedRiskLevels,omitempty"`
|
||||
}
|
||||
|
||||
func (s *aIAgentService) normalizeToolPolicy(raw string) (string, error) {
|
||||
raw = strings.TrimSpace(raw)
|
||||
if raw == "" {
|
||||
return "", nil
|
||||
}
|
||||
policy := normalizedAIAgentToolPolicy{}
|
||||
if err := json.Unmarshal([]byte(raw), &policy); err != nil {
|
||||
return "", errorsx.InvalidParam("ai agent tool policy must be valid JSON")
|
||||
}
|
||||
if policy.MaxTotalCalls < 0 || policy.MaxTotalCalls > 8 {
|
||||
return "", errorsx.InvalidParam("ai agent tool policy maxTotalCalls must be between 1 and 8")
|
||||
}
|
||||
if policy.MaxArgumentBytes < 0 || policy.MaxArgumentBytes > 64*1024 {
|
||||
return "", errorsx.InvalidParam("ai agent tool policy maxArgumentBytes must be between 1 and 65536")
|
||||
}
|
||||
seen := make(map[string]struct{}, len(policy.AllowedRiskLevels))
|
||||
riskLevels := make([]string, 0, len(policy.AllowedRiskLevels))
|
||||
for _, level := range policy.AllowedRiskLevels {
|
||||
level = strings.ToLower(strings.TrimSpace(level))
|
||||
if level == "" {
|
||||
continue
|
||||
}
|
||||
if level != "read" && level != "write" && level != "sensitive" {
|
||||
return "", errorsx.InvalidParam("ai agent tool policy contains an invalid risk level")
|
||||
}
|
||||
if _, exists := seen[level]; exists {
|
||||
continue
|
||||
}
|
||||
seen[level] = struct{}{}
|
||||
riskLevels = append(riskLevels, level)
|
||||
}
|
||||
policy.AllowedRiskLevels = riskLevels
|
||||
data, err := json.Marshal(policy)
|
||||
if err != nil {
|
||||
return "", errorsx.InvalidParam("ai agent tool policy is invalid")
|
||||
}
|
||||
return string(data), nil
|
||||
}
|
||||
|
||||
func (s *aIAgentService) normalizeKnowledgeBaseIDs(input []int64) ([]int64, error) {
|
||||
ret := make([]int64, 0, len(input))
|
||||
seen := make(map[int64]struct{})
|
||||
for _, id := range input {
|
||||
if id <= 0 {
|
||||
continue
|
||||
}
|
||||
if _, exists := seen[id]; exists {
|
||||
continue
|
||||
}
|
||||
knowledgeBase := KnowledgeBaseService.Get(id)
|
||||
if knowledgeBase == nil || knowledgeBase.Status != enums.StatusOk {
|
||||
return nil, errorsx.InvalidParam("knowledge base is not available")
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
ret = append(ret, id)
|
||||
}
|
||||
slices.Sort(ret)
|
||||
return ret, nil
|
||||
}
|
||||
|
||||
func (s *aIAgentService) normalizeTeamIDs(input []int64) ([]int64, error) {
|
||||
ret := make([]int64, 0, len(input))
|
||||
seen := make(map[int64]struct{})
|
||||
@@ -271,11 +531,17 @@ func (s *aIAgentService) normalizeDirectTools(input []request.AIAgentMCPToolRequ
|
||||
if toolx.IsAutoInjectedToolCode(strings.TrimSpace(normalized.ToolCode)) {
|
||||
continue
|
||||
}
|
||||
if toolx.ResolveToolSourceType(normalized.ToolCode) != enums.ToolSourceTypeMCP {
|
||||
return nil, errorsx.InvalidParamI18n("error.e0020")
|
||||
}
|
||||
if err := ToolCatalogService.ValidateToolCode(normalized.ToolCode); err != nil {
|
||||
return nil, err
|
||||
if spec, registered := toolx.GetRegisteredToolSpec(normalized.ToolCode); registered {
|
||||
if !spec.DirectAccess || spec.AutoInjected || (spec.Code != toolx.BuiltinConversationContext.Code && spec.Code != toolx.BuiltinKnowledgeRetrieve.Code && spec.Code != toolx.GraphTriageServiceRequest.Code && spec.Code != toolx.GraphAnalyzeConversation.Code && spec.Code != toolx.GraphPrepareTicketDraft.Code) {
|
||||
return nil, errorsx.InvalidParamI18n("error.e0020")
|
||||
}
|
||||
} else {
|
||||
if toolx.ResolveToolSourceType(normalized.ToolCode) != enums.ToolSourceTypeMCP {
|
||||
return nil, errorsx.InvalidParamI18n("error.e0020")
|
||||
}
|
||||
if err := ToolCatalogService.ValidateToolCode(normalized.ToolCode); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
key := strings.TrimSpace(normalized.ToolCode)
|
||||
if _, exists := seen[key]; exists {
|
||||
|
||||
@@ -12,13 +12,14 @@ import (
|
||||
"agent-desk/internal/pkg/dto"
|
||||
"agent-desk/internal/pkg/dto/request"
|
||||
"agent-desk/internal/pkg/enums"
|
||||
"agent-desk/internal/pkg/toolx"
|
||||
|
||||
"github.com/glebarez/sqlite"
|
||||
"github.com/mlogclub/simple/sqls"
|
||||
"gorm.io/gorm"
|
||||
)
|
||||
|
||||
func TestAIAgentServiceCreatesDefaultWorkflow(t *testing.T) {
|
||||
func TestAIAgentServiceCreatesWorkflowOnlyWhenRequested(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
operator := aiAgentWorkflowTestOperator()
|
||||
aiConfigID := createAIAgentWorkflowTestConfig(t)
|
||||
@@ -26,6 +27,7 @@ func TestAIAgentServiceCreatesDefaultWorkflow(t *testing.T) {
|
||||
item, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
|
||||
Name: "workflow agent",
|
||||
AIConfigID: aiConfigID,
|
||||
RuntimeMode: enums.AIAgentRuntimeModeWorkflow,
|
||||
ServiceMode: enums.IMConversationServiceModeAIOnly,
|
||||
HandoffMode: enums.AIAgentHandoffModeWaitPool,
|
||||
FallbackMode: enums.AIAgentFallbackModeNoAnswer,
|
||||
@@ -33,6 +35,15 @@ func TestAIAgentServiceCreatesDefaultWorkflow(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatalf("CreateAIAgent() error = %v", err)
|
||||
}
|
||||
if item.RuntimeMode != enums.AIAgentRuntimeModeWorkflow {
|
||||
t.Fatalf("default runtime mode = %q, want %q", item.RuntimeMode, enums.AIAgentRuntimeModeWorkflow)
|
||||
}
|
||||
if item.MaxSteps != 6 {
|
||||
t.Fatalf("default max steps = %d, want 6", item.MaxSteps)
|
||||
}
|
||||
if item.RolloutPercent != 100 {
|
||||
t.Fatalf("workflow rollout default = %d, want 100", item.RolloutPercent)
|
||||
}
|
||||
|
||||
workflow, err := AIWorkflowService.GetOrCreateAgentWorkflow(item.ID, operator)
|
||||
if err != nil {
|
||||
@@ -81,10 +92,12 @@ func TestAIAgentServiceCreatesDefaultWorkflow(t *testing.T) {
|
||||
}
|
||||
}
|
||||
assertConditionBranchToNodeType(t, stored, "policy_route_1", workflowregistry.NodeTypeSendReply, "eq", "direct_reply")
|
||||
assertConditionBranchToNodeType(t, stored, "policy_route_1", workflowregistry.NodeTypeHandoffToHuman, "eq", "handoff_to_human")
|
||||
assertConditionBranchToNodeID(t, stored, "policy_route_1", "handoff_confirm_prompt_1", "eq", "handoff_to_human")
|
||||
assertConditionBranchToNodeType(t, stored, "policy_route_1", workflowregistry.NodeTypePrepareTicketDraft, "eq", "prepare_ticket")
|
||||
assertConditionBranchToNodeID(t, stored, "ticket_draft_route_1", "ticket_confirm_prompt_1", "is_true", nil)
|
||||
assertDefaultBranchToNodeID(t, stored, "ticket_draft_route_1", "ticket_followup_reply_1")
|
||||
assertConditionBranchToNodeID(t, stored, "handoff_confirm_route_1", "handoff_1", "is_true", nil)
|
||||
assertDefaultBranchToNodeID(t, stored, "handoff_confirm_route_1", "handoff_cancel_reply_1")
|
||||
assertConditionBranchToNodeID(t, stored, "answerability_route_1", "reply_1", "eq", "answerable")
|
||||
assertDefaultBranchToNodeID(t, stored, "answerability_route_1", "fallback_reply_1")
|
||||
if !workflowEdgeExists(stored, "create_ticket_1", "ticket_result_reply_1") {
|
||||
@@ -93,6 +106,7 @@ func TestAIAgentServiceCreatesDefaultWorkflow(t *testing.T) {
|
||||
assertConditionBranchesHavePortEdges(t, stored, "policy_route_1")
|
||||
assertConditionBranchesHavePortEdges(t, stored, "ticket_draft_route_1")
|
||||
assertConditionBranchesHavePortEdges(t, stored, "ticket_confirm_route_1")
|
||||
assertConditionBranchesHavePortEdges(t, stored, "handoff_confirm_route_1")
|
||||
assertConditionBranchesHavePortEdges(t, stored, "answerability_route_1")
|
||||
assertConditionBranchOrder(t, stored, "policy_route_1", []string{
|
||||
"handoff",
|
||||
@@ -114,6 +128,230 @@ func TestAIAgentServiceCreatesDefaultWorkflow(t *testing.T) {
|
||||
})
|
||||
}
|
||||
|
||||
func TestAIAgentServiceDefaultsNewAutonomousAgentToSmallRollout(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
item, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
|
||||
Name: "small-rollout autonomous agent", AIConfigID: createAIAgentWorkflowTestConfig(t), RuntimeMode: enums.AIAgentRuntimeModeAutonomous,
|
||||
ServiceMode: enums.IMConversationServiceModeAIOnly, HandoffMode: enums.AIAgentHandoffModeWaitPool, FallbackMode: enums.AIAgentFallbackModeNoAnswer,
|
||||
}, aiAgentWorkflowTestOperator())
|
||||
if err != nil {
|
||||
t.Fatalf("CreateAIAgent: %v", err)
|
||||
}
|
||||
if item.RolloutPercent != defaultNewAutonomousRolloutPercent {
|
||||
t.Fatalf("autonomous rollout default = %d, want %d", item.RolloutPercent, defaultNewAutonomousRolloutPercent)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceDefaultsToAutonomousWithoutWorkflow(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
operator := aiAgentWorkflowTestOperator()
|
||||
item, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
|
||||
Name: "default autonomous agent", AIConfigID: createAIAgentWorkflowTestConfig(t),
|
||||
ServiceMode: enums.IMConversationServiceModeAIOnly, HandoffMode: enums.AIAgentHandoffModeWaitPool, FallbackMode: enums.AIAgentFallbackModeNoAnswer,
|
||||
}, operator)
|
||||
if err != nil {
|
||||
t.Fatalf("CreateAIAgent() error = %v", err)
|
||||
}
|
||||
if item.RuntimeMode != enums.AIAgentRuntimeModeAutonomous {
|
||||
t.Fatalf("default runtime mode = %q, want %q", item.RuntimeMode, enums.AIAgentRuntimeModeAutonomous)
|
||||
}
|
||||
var workflowCount int64
|
||||
if err := sqls.DB().Model(&models.AIWorkflow{}).Where("agent_id = ?", item.ID).Count(&workflowCount).Error; err != nil {
|
||||
t.Fatalf("count workflows: %v", err)
|
||||
}
|
||||
if workflowCount != 0 {
|
||||
t.Fatalf("default autonomous agent created %d workflows", workflowCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceCreatesWorkflowDraftForHybrid(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
item, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
|
||||
Name: "hybrid agent", AIConfigID: createAIAgentWorkflowTestConfig(t), RuntimeMode: enums.AIAgentRuntimeModeHybrid,
|
||||
ServiceMode: enums.IMConversationServiceModeAIOnly, HandoffMode: enums.AIAgentHandoffModeWaitPool, FallbackMode: enums.AIAgentFallbackModeNoAnswer,
|
||||
}, aiAgentWorkflowTestOperator())
|
||||
if err != nil {
|
||||
t.Fatalf("CreateAIAgent() error = %v", err)
|
||||
}
|
||||
var workflowCount int64
|
||||
if err := sqls.DB().Model(&models.AIWorkflow{}).Where("agent_id = ?", item.ID).Count(&workflowCount).Error; err != nil {
|
||||
t.Fatalf("count workflows: %v", err)
|
||||
}
|
||||
if workflowCount != 1 {
|
||||
t.Fatalf("hybrid agent created %d workflows, want 1", workflowCount)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceNormalizesToolPolicy(t *testing.T) {
|
||||
policy, err := AIAgentService.normalizeToolPolicy(`{"maxTotalCalls":2,"maxArgumentBytes":1024,"allowedRiskLevels":["READ","read","sensitive"]}`)
|
||||
if err != nil {
|
||||
t.Fatalf("normalizeToolPolicy: %v", err)
|
||||
}
|
||||
if !strings.Contains(policy, `"maxTotalCalls":2`) || !strings.Contains(policy, `"allowedRiskLevels":["read","sensitive"]`) {
|
||||
t.Fatalf("unexpected normalized policy: %s", policy)
|
||||
}
|
||||
if _, err := AIAgentService.normalizeToolPolicy(`{"allowedRiskLevels":["admin"]}`); err == nil {
|
||||
t.Fatal("expected invalid risk level error")
|
||||
}
|
||||
if _, err := AIAgentService.normalizeToolPolicy(`not-json`); err == nil {
|
||||
t.Fatal("expected invalid JSON error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceAllowsRegisteredReadDirectTool(t *testing.T) {
|
||||
tools, err := AIAgentService.normalizeDirectTools([]request.AIAgentMCPToolRequest{{ToolCode: toolx.BuiltinConversationContext.Code}})
|
||||
if err != nil {
|
||||
t.Fatalf("normalizeDirectTools: %v", err)
|
||||
}
|
||||
if len(tools) != 1 || tools[0].ToolCode != toolx.BuiltinConversationContext.Code {
|
||||
t.Fatalf("unexpected normalized direct tools: %#v", tools)
|
||||
}
|
||||
tools, err = AIAgentService.normalizeDirectTools([]request.AIAgentMCPToolRequest{{ToolCode: toolx.BuiltinKnowledgeRetrieve.Code}})
|
||||
if err != nil || len(tools) != 1 || tools[0].ToolCode != toolx.BuiltinKnowledgeRetrieve.Code {
|
||||
t.Fatalf("expected registered knowledge retrieve tool to be allowed, tools=%#v err=%v", tools, err)
|
||||
}
|
||||
tools, err = AIAgentService.normalizeDirectTools([]request.AIAgentMCPToolRequest{{ToolCode: toolx.GraphPrepareTicketDraft.Code}})
|
||||
if err != nil || len(tools) != 1 || tools[0].ToolCode != toolx.GraphPrepareTicketDraft.Code {
|
||||
t.Fatalf("expected registered ticket draft tool to be allowed, tools=%#v err=%v", tools, err)
|
||||
}
|
||||
tools, err = AIAgentService.normalizeDirectTools([]request.AIAgentMCPToolRequest{{ToolCode: toolx.GraphAnalyzeConversation.Code}})
|
||||
if err != nil || len(tools) != 1 || tools[0].ToolCode != toolx.GraphAnalyzeConversation.Code {
|
||||
t.Fatalf("expected registered conversation analysis tool to be allowed, tools=%#v err=%v", tools, err)
|
||||
}
|
||||
tools, err = AIAgentService.normalizeDirectTools([]request.AIAgentMCPToolRequest{{ToolCode: toolx.GraphTriageServiceRequest.Code}})
|
||||
if err != nil || len(tools) != 1 || tools[0].ToolCode != toolx.GraphTriageServiceRequest.Code {
|
||||
t.Fatalf("expected registered service triage tool to be allowed, tools=%#v err=%v", tools, err)
|
||||
}
|
||||
if _, err := AIAgentService.normalizeDirectTools([]request.AIAgentMCPToolRequest{{ToolCode: toolx.GraphHandoffConversation.Code}}); err == nil {
|
||||
t.Fatal("expected unsupported graph direct tool to be rejected")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceRollsBackToOwnPublishedRevision(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
db := sqls.DB()
|
||||
agent := &models.AIAgent{Name: "rollback-agent", Status: enums.StatusOk, RuntimeMode: enums.AIAgentRuntimeModeAutonomous}
|
||||
if err := db.Create(agent).Error; err != nil {
|
||||
t.Fatalf("create agent: %v", err)
|
||||
}
|
||||
revision := &models.AgentRevision{AgentID: agent.ID, Revision: 1, Status: enums.StatusOk}
|
||||
if err := db.Create(revision).Error; err != nil {
|
||||
t.Fatalf("create revision: %v", err)
|
||||
}
|
||||
if err := AIAgentService.RollbackAIAgent(agent.ID, revision.ID, aiAgentWorkflowTestOperator()); err != nil {
|
||||
t.Fatalf("RollbackAIAgent: %v", err)
|
||||
}
|
||||
if updated := AIAgentService.Get(agent.ID); updated == nil || updated.PublishedRevisionID != revision.ID {
|
||||
t.Fatalf("rollback did not bind revision: %#v", updated)
|
||||
}
|
||||
otherRevision := &models.AgentRevision{AgentID: agent.ID + 1, Revision: 1, Status: enums.StatusOk}
|
||||
if err := db.Create(otherRevision).Error; err != nil {
|
||||
t.Fatalf("create other revision: %v", err)
|
||||
}
|
||||
if err := AIAgentService.RollbackAIAgent(agent.ID, otherRevision.ID, aiAgentWorkflowTestOperator()); err == nil {
|
||||
t.Fatal("expected cross-agent revision rollback rejection")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceRollsBackPreviousRolloutPercent(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
agent := &models.AIAgent{
|
||||
Name: "rollout-agent",
|
||||
Status: enums.StatusOk,
|
||||
RuntimeMode: enums.AIAgentRuntimeModeAutonomous,
|
||||
RolloutPercent: 20,
|
||||
PreviousRolloutPercent: 100,
|
||||
}
|
||||
if err := sqls.DB().Create(agent).Error; err != nil {
|
||||
t.Fatalf("create agent: %v", err)
|
||||
}
|
||||
operator := aiAgentWorkflowTestOperator()
|
||||
if err := AIAgentService.RollbackAIAgentRollout(agent.ID, operator); err != nil {
|
||||
t.Fatalf("RollbackAIAgentRollout: %v", err)
|
||||
}
|
||||
updated := AIAgentService.Get(agent.ID)
|
||||
if updated == nil || updated.RolloutPercent != 100 || updated.PreviousRolloutPercent != 20 {
|
||||
t.Fatalf("unexpected rollout rollback result: %#v", updated)
|
||||
}
|
||||
if err := AIAgentService.RollbackAIAgentRollout(agent.ID, operator); err != nil {
|
||||
t.Fatalf("second RollbackAIAgentRollout: %v", err)
|
||||
}
|
||||
updated = AIAgentService.Get(agent.ID)
|
||||
if updated == nil || updated.RolloutPercent != 20 || updated.PreviousRolloutPercent != 100 {
|
||||
t.Fatalf("unexpected rollout redo result: %#v", updated)
|
||||
}
|
||||
if err := sqls.DB().Model(&models.AIAgent{}).Where("id = ?", agent.ID).Update("previous_rollout_percent", 0).Error; err != nil {
|
||||
t.Fatalf("clear previous rollout: %v", err)
|
||||
}
|
||||
if err := AIAgentService.RollbackAIAgentRollout(agent.ID, operator); err == nil {
|
||||
t.Fatal("expected missing previous rollout to be rejected")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceUpdateUnpublishesAutonomousAgent(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
operator := aiAgentWorkflowTestOperator()
|
||||
agent, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
|
||||
Name: "autonomous agent", AIConfigID: createAIAgentWorkflowTestConfig(t), RuntimeMode: enums.AIAgentRuntimeModeAutonomous,
|
||||
ServiceMode: enums.IMConversationServiceModeAIOnly, HandoffMode: enums.AIAgentHandoffModeWaitPool, FallbackMode: enums.AIAgentFallbackModeNoAnswer,
|
||||
}, operator)
|
||||
if err != nil {
|
||||
t.Fatalf("CreateAIAgent() error = %v", err)
|
||||
}
|
||||
if _, err := AIAgentService.PublishAIAgent(agent.ID, operator); err != nil {
|
||||
t.Fatalf("PublishAIAgent() error = %v", err)
|
||||
}
|
||||
if published := AIAgentService.Get(agent.ID); published == nil || published.PublishedRevisionID <= 0 {
|
||||
t.Fatalf("expected published autonomous agent, got %#v", published)
|
||||
}
|
||||
if err := AIAgentService.UpdateAIAgent(request.UpdateAIAgentRequest{ID: agent.ID, CreateAIAgentRequest: request.CreateAIAgentRequest{
|
||||
Name: agent.Name, Description: "changed draft", AIConfigID: agent.AIConfigID, RuntimeMode: enums.AIAgentRuntimeModeAutonomous,
|
||||
ServiceMode: enums.IMConversationServiceModeAIOnly, HandoffMode: enums.AIAgentHandoffModeWaitPool, FallbackMode: enums.AIAgentFallbackModeNoAnswer,
|
||||
}}, operator); err != nil {
|
||||
t.Fatalf("UpdateAIAgent() error = %v", err)
|
||||
}
|
||||
if updated := AIAgentService.Get(agent.ID); updated == nil || updated.PublishedRevisionID != 0 {
|
||||
t.Fatalf("expected autonomous update to clear published revision, got %#v", updated)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceRejectsPublishWithUnavailableModelConfig(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
operator := aiAgentWorkflowTestOperator()
|
||||
configID := createAIAgentWorkflowTestConfig(t)
|
||||
agent, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
|
||||
Name: "unavailable model agent", AIConfigID: configID, RuntimeMode: enums.AIAgentRuntimeModeAutonomous,
|
||||
ServiceMode: enums.IMConversationServiceModeAIOnly, HandoffMode: enums.AIAgentHandoffModeWaitPool, FallbackMode: enums.AIAgentFallbackModeNoAnswer,
|
||||
}, operator)
|
||||
if err != nil {
|
||||
t.Fatalf("CreateAIAgent() error = %v", err)
|
||||
}
|
||||
if err := sqls.DB().Model(&models.AIConfig{}).Where("id = ?", configID).Update("status", enums.StatusDisabled).Error; err != nil {
|
||||
t.Fatalf("disable model config: %v", err)
|
||||
}
|
||||
if _, err := AIAgentService.PublishAIAgent(agent.ID, operator); err == nil {
|
||||
t.Fatal("expected unavailable model config to reject publishing")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIAgentServiceRejectsPublishWithSensitiveDirectTool(t *testing.T) {
|
||||
setupAIAgentWorkflowTestDB(t)
|
||||
operator := aiAgentWorkflowTestOperator()
|
||||
agent, err := AIAgentService.CreateAIAgent(request.CreateAIAgentRequest{
|
||||
Name: "sensitive tool agent", AIConfigID: createAIAgentWorkflowTestConfig(t), RuntimeMode: enums.AIAgentRuntimeModeAutonomous,
|
||||
ServiceMode: enums.IMConversationServiceModeAIOnly, HandoffMode: enums.AIAgentHandoffModeWaitPool, FallbackMode: enums.AIAgentFallbackModeNoAnswer,
|
||||
}, operator)
|
||||
if err != nil {
|
||||
t.Fatalf("CreateAIAgent() error = %v", err)
|
||||
}
|
||||
if err := sqls.DB().Model(&models.AIAgent{}).Where("id = ?", agent.ID).Update("allowed_mcp_tools", `[{"toolCode":"mcp/demo/write_order"}]`).Error; err != nil {
|
||||
t.Fatalf("set direct tool: %v", err)
|
||||
}
|
||||
if _, err := AIAgentService.PublishAIAgent(agent.ID, operator); err == nil || !strings.Contains(err.Error(), "confirmed playbook") {
|
||||
t.Fatalf("expected sensitive direct tool publish rejection, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIWorkflowServiceDefaultAgentWorkflowDefinitionRequiresKnowledgeRetrieveConfiguration(t *testing.T) {
|
||||
definition := AIWorkflowService.DefaultAgentWorkflowDefinition()
|
||||
if definition.SchemaVersion != dsl.SchemaVersion || nodeTypeByID(definition, "start_1") != workflowregistry.NodeTypeStart {
|
||||
@@ -135,6 +373,13 @@ func TestAIWorkflowServiceDefaultAgentWorkflowDefinitionRequiresKnowledgeRetriev
|
||||
if !workflowHasNodeType(definition, workflowregistry.NodeTypeCreateTicket) {
|
||||
t.Fatalf("expected default workflow to include ticket creation node")
|
||||
}
|
||||
if nodeTypeByID(definition, "handoff_confirm_1") != workflowregistry.NodeTypeHumanConfirm {
|
||||
t.Fatalf("expected default workflow handoff path to include human confirmation")
|
||||
}
|
||||
handoff := workflowNodeByID(t, definition, "handoff_1")
|
||||
if nodeID, field, ok := handoff.Data.InputsValues["confirmed"].Ref(); !ok || nodeID != "handoff_confirm_1" || field != "confirmed" {
|
||||
t.Fatalf("expected handoff to use confirmation result, got %#v", handoff.Data.InputsValues["confirmed"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIWorkflowServiceDefaultAgentWorkflowTicketPromptIncludesDraftFields(t *testing.T) {
|
||||
@@ -203,6 +448,19 @@ func TestAIWorkflowServicePublishAgentWorkflowBindsAgentVersion(t *testing.T) {
|
||||
if storedAgent.WorkflowVersionID != version.ID {
|
||||
t.Fatalf("expected agent workflow version %d, got %d", version.ID, storedAgent.WorkflowVersionID)
|
||||
}
|
||||
if storedAgent.PublishedRevisionID <= 0 {
|
||||
t.Fatalf("expected published agent revision id, got %d", storedAgent.PublishedRevisionID)
|
||||
}
|
||||
var revision models.AgentRevision
|
||||
if err := sqls.DB().First(&revision, storedAgent.PublishedRevisionID).Error; err != nil {
|
||||
t.Fatalf("load agent revision: %v", err)
|
||||
}
|
||||
if revision.AgentID != agent.ID || revision.WorkflowVersionID != version.ID || revision.Revision != 1 || revision.DefinitionHash == "" {
|
||||
t.Fatalf("unexpected published agent revision: %#v", revision)
|
||||
}
|
||||
if !strings.Contains(revision.Definition, `"modelName":"gpt-test"`) || strings.Contains(revision.Definition, "revision-test-secret") {
|
||||
t.Fatalf("unexpected revision definition: %s", revision.Definition)
|
||||
}
|
||||
}
|
||||
|
||||
func setupAIAgentWorkflowTestDB(t *testing.T) {
|
||||
@@ -211,7 +469,7 @@ func setupAIAgentWorkflowTestDB(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatalf("open sqlite db: %v", err)
|
||||
}
|
||||
if err := db.AutoMigrate(&models.AIAgent{}, &models.AIConfig{}, &models.KnowledgeBase{}, &models.AIWorkflow{}, &models.AIWorkflowVersion{}); err != nil {
|
||||
if err := db.AutoMigrate(&models.AIAgent{}, &models.AIConfig{}, &models.KnowledgeBase{}, &models.AIWorkflow{}, &models.AIWorkflowVersion{}, &models.AgentRevision{}); err != nil {
|
||||
t.Fatalf("auto migrate: %v", err)
|
||||
}
|
||||
sqls.SetDB(db)
|
||||
@@ -222,6 +480,7 @@ func createAIAgentWorkflowTestConfig(t *testing.T) int64 {
|
||||
item := &models.AIConfig{
|
||||
Name: "workflow-test-config",
|
||||
Provider: enums.AIProviderOpenAI,
|
||||
APIKey: "revision-test-secret",
|
||||
ModelType: enums.AIModelTypeLLM,
|
||||
ModelName: "gpt-test",
|
||||
Status: enums.StatusOk,
|
||||
|
||||
@@ -42,6 +42,13 @@ type AIWorkflowRunAuditItem struct {
|
||||
Agent *models.AIAgent
|
||||
}
|
||||
|
||||
type AIWorkflowTemplate struct {
|
||||
Code string
|
||||
Name string
|
||||
Description string
|
||||
Definition dsl.Definition
|
||||
}
|
||||
|
||||
func (s *aiWorkflowService) Get(id int64) *models.AIWorkflow {
|
||||
if id <= 0 {
|
||||
return nil
|
||||
@@ -194,6 +201,46 @@ func (s *aiWorkflowService) DefaultAgentWorkflowDefinition() dsl.Definition {
|
||||
return defaultAgentWorkflowDefinition()
|
||||
}
|
||||
|
||||
func (s *aiWorkflowService) ListPlaybookTemplates() []AIWorkflowTemplate {
|
||||
return []AIWorkflowTemplate{
|
||||
{Code: "ticket-with-confirmation", Name: "创建工单", Description: "整理工单草稿，经客户确认后创建工单。", Definition: ticketWithConfirmationPlaybookDefinition()},
|
||||
{Code: "identity-confirmation", Name: "身份确认", Description: "在执行后续业务前收集客户的明确确认。", Definition: identityConfirmationPlaybookDefinition()},
|
||||
{Code: "complaint-escalation", Name: "投诉升级", Description: "投诉场景经客户确认后转入人工客服处理。", Definition: complaintEscalationPlaybookDefinition()},
|
||||
{Code: "refund-request-preparation", Name: "退款申请准备", Description: "整理退款诉求，确认后转人工继续核验和处理。", Definition: refundRequestPreparationPlaybookDefinition()},
|
||||
}
|
||||
}
|
||||
|
||||
func ticketWithConfirmationPlaybookDefinition() dsl.Definition {
|
||||
return dsl.Definition{SchemaVersion: dsl.SchemaVersion,
|
||||
Nodes: []dsl.Node{
|
||||
workflowNode("start_1", workflowregistry.NodeTypeStart, "开始", 180, 180, nil, nil),
|
||||
workflowNode("draft_1", workflowregistry.NodeTypePrepareTicketDraft, "整理工单草稿", 600, 180, workflowInputs("issue", "start_1", "userMessage"), nil),
|
||||
workflowNode("ready_route_1", workflowregistry.NodeTypeCondition, "草稿分流", 1020, 180, nil, dsl.ConditionConfig{Branches: []dsl.ConditionBranch{
|
||||
workflowConditionBranch("ready", "草稿完整", "prompt_1", "draft_1", "ready", "is_true", nil),
|
||||
{ID: "default", Name: "补充信息", TargetNodeID: "followup_1", Default: true},
|
||||
}}),
|
||||
workflowNode("prompt_1", workflowregistry.NodeTypeLLMReply, "建单确认", 1440, 100, map[string]dsl.Value{"userMessage": dsl.RefValue("start_1", "userMessage"), "ticketTitle": dsl.RefValue("draft_1", "title"), "ticketDescription": dsl.RefValue("draft_1", "description")}, map[string]any{"staticReply": "我已整理工单草稿：{{ticketTitle}}。请确认是否创建。"}),
|
||||
workflowNode("confirm_1", workflowregistry.NodeTypeHumanConfirm, "确认建单", 1860, 100, workflowInputs("prompt", "prompt_1", "replyText"), nil),
|
||||
workflowNode("confirm_route_1", workflowregistry.NodeTypeCondition, "确认分流", 2280, 100, nil, dsl.ConditionConfig{Branches: []dsl.ConditionBranch{
|
||||
workflowConditionBranch("confirmed", "已确认", "create_1", "confirm_1", "confirmed", "is_true", nil),
|
||||
{ID: "default", Name: "取消", TargetNodeID: "cancel_1", Default: true},
|
||||
}}),
|
||||
workflowNode("create_1", workflowregistry.NodeTypeCreateTicket, "创建工单", 2700, 20, map[string]dsl.Value{"ticketDraft": dsl.RefValue("draft_1", "ticketDraft"), "confirmed": dsl.RefValue("confirm_1", "confirmed")}, nil),
|
||||
workflowNode("followup_1", workflowregistry.NodeTypeLLMReply, "补充信息", 1440, 330, map[string]dsl.Value{"userMessage": dsl.RefValue("start_1", "userMessage"), "followUpQuestions": dsl.RefValue("draft_1", "followUpQuestions")}, map[string]any{"staticReply": "创建工单前还需要补充：{{followUpQuestions}}"}),
|
||||
workflowNode("cancel_1", workflowregistry.NodeTypeLLMReply, "取消提示", 2700, 200, workflowInputs("userMessage", "start_1", "userMessage"), map[string]any{"staticReply": "已取消创建工单。"}),
|
||||
workflowNode("send_result_1", workflowregistry.NodeTypeSendReply, "发送建单结果", 3120, 20, workflowInputs("replyText", "create_1", "message"), nil),
|
||||
workflowNode("send_followup_1", workflowregistry.NodeTypeSendReply, "发送补充提示", 1860, 330, workflowInputs("replyText", "followup_1", "replyText"), nil),
|
||||
workflowNode("send_cancel_1", workflowregistry.NodeTypeSendReply, "发送取消提示", 3120, 200, workflowInputs("replyText", "cancel_1", "replyText"), nil),
|
||||
workflowNode("end_1", workflowregistry.NodeTypeEnd, "结束", 3540, 180, nil, nil),
|
||||
},
|
||||
Edges: []dsl.Edge{
|
||||
workflowEdge("start_1", "draft_1"), workflowEdge("draft_1", "ready_route_1"), workflowPortEdge("ready_route_1", "prompt_1", "ready"), workflowPortEdge("ready_route_1", "followup_1", "default"),
|
||||
workflowEdge("prompt_1", "confirm_1"), workflowEdge("confirm_1", "confirm_route_1"), workflowPortEdge("confirm_route_1", "create_1", "confirmed"), workflowPortEdge("confirm_route_1", "cancel_1", "default"),
|
||||
workflowEdge("create_1", "send_result_1"), workflowEdge("send_result_1", "end_1"), workflowEdge("followup_1", "send_followup_1"), workflowEdge("send_followup_1", "end_1"), workflowEdge("cancel_1", "send_cancel_1"), workflowEdge("send_cancel_1", "end_1"),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (s *aiWorkflowService) ValidateDefinition(def dsl.Definition) workflowvalidator.Result {
|
||||
return workflowvalidator.ValidateDefinition(def, s.registry)
|
||||
}
|
||||
@@ -390,11 +437,23 @@ func (s *aiWorkflowService) PublishAgentWorkflow(req request.PublishAIWorkflowRe
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
agent := repositories.AIAgentRepository.Get(ctx.Tx, req.AgentID)
|
||||
if agent == nil {
|
||||
return errorsx.InvalidParamI18n("error.e0002")
|
||||
}
|
||||
if err := AIAgentService.validatePublishableAgent(ctx.Tx, agent); err != nil {
|
||||
return err
|
||||
}
|
||||
revision, err := AgentRevisionService.PublishWorkflowSnapshot(ctx.Tx, agent, version, operator)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return repositories.AIAgentRepository.Updates(ctx.Tx, req.AgentID, map[string]any{
|
||||
"workflow_version_id": version.ID,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": now,
|
||||
"workflow_version_id": version.ID,
|
||||
"published_revision_id": revision.ID,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": now,
|
||||
})
|
||||
})
|
||||
if err != nil {
|
||||
@@ -434,7 +493,7 @@ func defaultAgentWorkflowDefinition() dsl.Definition {
|
||||
"riskSignals": dsl.RefValue("understanding_1", "riskSignals"),
|
||||
}, nil),
|
||||
workflowNode("policy_route_1", workflowregistry.NodeTypeCondition, "策略分流", 1560, 125.5, nil, dsl.ConditionConfig{Branches: []dsl.ConditionBranch{
|
||||
workflowConditionBranch("handoff", "转人工", "handoff_1", "policy_1", "action", "eq", "handoff_to_human"),
|
||||
workflowConditionBranch("handoff", "转人工", "handoff_confirm_prompt_1", "policy_1", "action", "eq", "handoff_to_human"),
|
||||
workflowConditionBranch("direct", "直接回复", "policy_reply_1", "policy_1", "action", "eq", "direct_reply"),
|
||||
workflowConditionBranch("clarify", "追问澄清", "policy_reply_1", "policy_1", "action", "eq", "clarify"),
|
||||
workflowConditionBranch("end_conversation", "结束语", "policy_reply_1", "policy_1", "action", "eq", "end_conversation"),
|
||||
@@ -442,9 +501,20 @@ func defaultAgentWorkflowDefinition() dsl.Definition {
|
||||
workflowConditionBranch("knowledge", "知识库回复", "retrieve_1", "policy_1", "action", "eq", "retrieve_knowledge"),
|
||||
{ID: "default", Name: "策略兜底", TargetNodeID: "policy_reply_1", Default: true},
|
||||
}}),
|
||||
workflowNode("handoff_1", workflowregistry.NodeTypeHandoffToHuman, "转人工", 2020, 0, workflowInputs("reason", "start_1", "userMessage"), nil),
|
||||
workflowNode("handoff_confirm_prompt_1", workflowregistry.NodeTypeLLMReply, "转人工确认文案", 2020, 0, workflowInputs("userMessage", "start_1", "userMessage"), map[string]any{"staticReply": "我可以为你转接人工客服处理。请回复“确认”继续转人工，或回复“取消”继续由 AI 协助。"}),
|
||||
workflowNode("handoff_confirm_1", workflowregistry.NodeTypeHumanConfirm, "确认转人工", 2480, 0, workflowInputs("prompt", "handoff_confirm_prompt_1", "replyText"), nil),
|
||||
workflowNode("handoff_confirm_route_1", workflowregistry.NodeTypeCondition, "转人工确认分流", 2940, 0, nil, dsl.ConditionConfig{Branches: []dsl.ConditionBranch{
|
||||
workflowConditionBranch("confirmed", "已确认", "handoff_1", "handoff_confirm_1", "confirmed", "is_true", nil),
|
||||
{ID: "default", Name: "取消或未确认", TargetNodeID: "handoff_cancel_reply_1", Default: true},
|
||||
}}),
|
||||
workflowNode("handoff_1", workflowregistry.NodeTypeHandoffToHuman, "转人工", 3400, 0, map[string]dsl.Value{
|
||||
"reason": dsl.RefValue("start_1", "userMessage"),
|
||||
"confirmed": dsl.RefValue("handoff_confirm_1", "confirmed"),
|
||||
}, nil),
|
||||
workflowNode("handoff_cancel_reply_1", workflowregistry.NodeTypeLLMReply, "取消转人工提示", 3400, 480, workflowInputs("userMessage", "start_1", "userMessage"), map[string]any{"staticReply": "已取消转人工。你可以继续补充问题，我会继续协助。"}),
|
||||
workflowNode("send_handoff_cancel_1", workflowregistry.NodeTypeSendReply, "发送取消提示", 3860, 480, workflowInputs("replyText", "handoff_cancel_reply_1", "replyText"), nil),
|
||||
workflowNode("policy_reply_1", workflowregistry.NodeTypeSendReply, "发送策略回复", 4320, 98.5, workflowInputs("replyText", "policy_1", "replyText"), nil),
|
||||
workflowNode("handoff_end_1", workflowregistry.NodeTypeEnd, "结束", 2480, 0, nil, nil),
|
||||
workflowNode("handoff_end_1", workflowregistry.NodeTypeEnd, "结束", 3860, 0, nil, nil),
|
||||
workflowNode("draft_ticket_1", workflowregistry.NodeTypePrepareTicketDraft, "整理工单草稿", 2020, 379, workflowInputs("issue", "start_1", "userMessage"), nil),
|
||||
workflowNode("ticket_draft_route_1", workflowregistry.NodeTypeCondition, "草稿就绪分流", 2480, 329, nil, dsl.ConditionConfig{Branches: []dsl.ConditionBranch{
|
||||
workflowConditionBranch("ready", "草稿完整", "ticket_confirm_prompt_1", "draft_ticket_1", "ready", "is_true", nil),
|
||||
@@ -497,7 +567,7 @@ func defaultAgentWorkflowDefinition() dsl.Definition {
|
||||
workflowEdge("start_1", "understanding_1"),
|
||||
workflowEdge("understanding_1", "policy_1"),
|
||||
workflowEdge("policy_1", "policy_route_1"),
|
||||
workflowPortEdge("policy_route_1", "handoff_1", "handoff"),
|
||||
workflowPortEdge("policy_route_1", "handoff_confirm_prompt_1", "handoff"),
|
||||
workflowPortEdge("policy_route_1", "policy_reply_1", "direct"),
|
||||
workflowPortEdge("policy_route_1", "policy_reply_1", "clarify"),
|
||||
workflowPortEdge("policy_route_1", "policy_reply_1", "end_conversation"),
|
||||
@@ -505,7 +575,13 @@ func defaultAgentWorkflowDefinition() dsl.Definition {
|
||||
workflowPortEdge("policy_route_1", "retrieve_1", "knowledge"),
|
||||
workflowPortEdge("policy_route_1", "policy_reply_1", "default"),
|
||||
workflowEdge("policy_reply_1", "end_1"),
|
||||
workflowEdge("handoff_confirm_prompt_1", "handoff_confirm_1"),
|
||||
workflowEdge("handoff_confirm_1", "handoff_confirm_route_1"),
|
||||
workflowPortEdge("handoff_confirm_route_1", "handoff_1", "confirmed"),
|
||||
workflowPortEdge("handoff_confirm_route_1", "handoff_cancel_reply_1", "default"),
|
||||
workflowEdge("handoff_1", "handoff_end_1"),
|
||||
workflowEdge("handoff_cancel_reply_1", "send_handoff_cancel_1"),
|
||||
workflowEdge("send_handoff_cancel_1", "end_1"),
|
||||
workflowEdge("draft_ticket_1", "ticket_draft_route_1"),
|
||||
workflowPortEdge("ticket_draft_route_1", "ticket_confirm_prompt_1", "ready"),
|
||||
workflowPortEdge("ticket_draft_route_1", "ticket_followup_reply_1", "default"),
|
||||
@@ -531,6 +607,62 @@ func defaultAgentWorkflowDefinition() dsl.Definition {
|
||||
}
|
||||
}
|
||||
|
||||
func identityConfirmationPlaybookDefinition() dsl.Definition {
|
||||
return dsl.Definition{SchemaVersion: dsl.SchemaVersion,
|
||||
Nodes: []dsl.Node{
|
||||
workflowNode("start_1", workflowregistry.NodeTypeStart, "开始", 180, 180, nil, nil),
|
||||
workflowNode("prompt_1", workflowregistry.NodeTypeLLMReply, "身份确认提示", 600, 180, workflowInputs("userMessage", "start_1", "userMessage"), map[string]any{"staticReply": "为保护你的账户信息，请确认是否继续身份核验。"}),
|
||||
workflowNode("confirm_1", workflowregistry.NodeTypeHumanConfirm, "确认身份核验", 1020, 180, workflowInputs("prompt", "prompt_1", "replyText"), nil),
|
||||
workflowNode("route_1", workflowregistry.NodeTypeCondition, "确认分流", 1440, 180, nil, dsl.ConditionConfig{Branches: []dsl.ConditionBranch{
|
||||
workflowConditionBranch("confirmed", "已确认", "confirmed_reply_1", "confirm_1", "confirmed", "is_true", nil),
|
||||
{ID: "default", Name: "取消", TargetNodeID: "cancel_reply_1", Default: true},
|
||||
}}),
|
||||
workflowNode("confirmed_reply_1", workflowregistry.NodeTypeLLMReply, "确认结果", 1860, 100, workflowInputs("userMessage", "start_1", "userMessage"), map[string]any{"staticReply": "已收到确认，人工客服将继续为你核验身份。"}),
|
||||
workflowNode("cancel_reply_1", workflowregistry.NodeTypeLLMReply, "取消提示", 1860, 280, workflowInputs("userMessage", "start_1", "userMessage"), map[string]any{"staticReply": "已取消身份核验。"}),
|
||||
workflowNode("send_confirmed_1", workflowregistry.NodeTypeSendReply, "发送确认结果", 2280, 100, workflowInputs("replyText", "confirmed_reply_1", "replyText"), nil),
|
||||
workflowNode("send_cancel_1", workflowregistry.NodeTypeSendReply, "发送取消提示", 2280, 280, workflowInputs("replyText", "cancel_reply_1", "replyText"), nil),
|
||||
workflowNode("end_1", workflowregistry.NodeTypeEnd, "结束", 2700, 180, nil, nil),
|
||||
},
|
||||
Edges: []dsl.Edge{
|
||||
workflowEdge("start_1", "prompt_1"), workflowEdge("prompt_1", "confirm_1"), workflowEdge("confirm_1", "route_1"),
|
||||
workflowPortEdge("route_1", "confirmed_reply_1", "confirmed"), workflowPortEdge("route_1", "cancel_reply_1", "default"),
|
||||
workflowEdge("confirmed_reply_1", "send_confirmed_1"), workflowEdge("cancel_reply_1", "send_cancel_1"), workflowEdge("send_confirmed_1", "end_1"), workflowEdge("send_cancel_1", "end_1"),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func complaintEscalationPlaybookDefinition() dsl.Definition {
|
||||
return confirmationHandoffPlaybookDefinition("投诉升级确认", "我们将把本次投诉升级给人工客服处理。请确认是否继续。", "已为你升级投诉，人工客服会尽快跟进。", "投诉升级已取消。")
|
||||
}
|
||||
|
||||
func confirmationHandoffPlaybookDefinition(title, prompt, confirmedReply, cancelledReply string) dsl.Definition {
|
||||
return dsl.Definition{SchemaVersion: dsl.SchemaVersion,
|
||||
Nodes: []dsl.Node{
|
||||
workflowNode("start_1", workflowregistry.NodeTypeStart, "开始", 180, 180, nil, nil),
|
||||
workflowNode("prompt_1", workflowregistry.NodeTypeLLMReply, title, 600, 180, workflowInputs("userMessage", "start_1", "userMessage"), map[string]any{"staticReply": prompt}),
|
||||
workflowNode("confirm_1", workflowregistry.NodeTypeHumanConfirm, "确认升级", 1020, 180, workflowInputs("prompt", "prompt_1", "replyText"), nil),
|
||||
workflowNode("route_1", workflowregistry.NodeTypeCondition, "确认分流", 1440, 180, nil, dsl.ConditionConfig{Branches: []dsl.ConditionBranch{
|
||||
workflowConditionBranch("confirmed", "已确认", "handoff_1", "confirm_1", "confirmed", "is_true", nil),
|
||||
{ID: "default", Name: "取消", TargetNodeID: "cancel_reply_1", Default: true},
|
||||
}}),
|
||||
workflowNode("handoff_1", workflowregistry.NodeTypeHandoffToHuman, "转人工处理", 1860, 100, map[string]dsl.Value{"reason": dsl.RefValue("start_1", "userMessage"), "confirmed": dsl.RefValue("confirm_1", "confirmed")}, nil),
|
||||
workflowNode("cancel_reply_1", workflowregistry.NodeTypeLLMReply, "取消提示", 1860, 280, workflowInputs("userMessage", "start_1", "userMessage"), map[string]any{"staticReply": cancelledReply}),
|
||||
workflowNode("send_handoff_1", workflowregistry.NodeTypeSendReply, "发送升级结果", 2280, 100, workflowInputs("replyText", "handoff_1", "message"), nil),
|
||||
workflowNode("send_cancel_1", workflowregistry.NodeTypeSendReply, "发送取消提示", 2280, 280, workflowInputs("replyText", "cancel_reply_1", "replyText"), nil),
|
||||
workflowNode("end_1", workflowregistry.NodeTypeEnd, "结束", 2700, 180, nil, nil),
|
||||
},
|
||||
Edges: []dsl.Edge{
|
||||
workflowEdge("start_1", "prompt_1"), workflowEdge("prompt_1", "confirm_1"), workflowEdge("confirm_1", "route_1"),
|
||||
workflowPortEdge("route_1", "handoff_1", "confirmed"), workflowPortEdge("route_1", "cancel_reply_1", "default"),
|
||||
workflowEdge("handoff_1", "send_handoff_1"), workflowEdge("cancel_reply_1", "send_cancel_1"), workflowEdge("send_handoff_1", "end_1"), workflowEdge("send_cancel_1", "end_1"),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func refundRequestPreparationPlaybookDefinition() dsl.Definition {
|
||||
return confirmationHandoffPlaybookDefinition("退款申请确认", "我会先整理退款申请并转交人工客服核验。请确认是否继续。", "退款申请已准备完成，人工客服将继续核验订单和退款条件。", "退款申请准备已取消。")
|
||||
}
|
||||
|
||||
func workflowNode(id string, nodeType string, title string, x float64, y float64, inputs map[string]dsl.Value, config any) dsl.Node {
|
||||
return dsl.Node{
|
||||
ID: id,
|
||||
|
||||
@@ -83,6 +83,26 @@ func TestAIWorkflowServicePublishCreatesImmutableVersion(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIWorkflowServicePlaybookTemplatesAreValid(t *testing.T) {
|
||||
templates := AIWorkflowService.ListPlaybookTemplates()
|
||||
if len(templates) != 4 {
|
||||
t.Fatalf("template count = %d, want 4", len(templates))
|
||||
}
|
||||
seen := make(map[string]struct{}, len(templates))
|
||||
for _, item := range templates {
|
||||
if item.Code == "" || item.Name == "" {
|
||||
t.Fatalf("template identity is required: %#v", item)
|
||||
}
|
||||
if _, exists := seen[item.Code]; exists {
|
||||
t.Fatalf("duplicate template code: %s", item.Code)
|
||||
}
|
||||
seen[item.Code] = struct{}{}
|
||||
if result := AIWorkflowService.ValidateDefinition(item.Definition); !result.Valid {
|
||||
t.Fatalf("template %s is invalid: %#v", item.Code, result.Errors)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAIWorkflowServicePublishIncrementsVersion(t *testing.T) {
|
||||
setupAIWorkflowTestDB(t)
|
||||
operator := aiWorkflowTestOperator()
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
package services
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
aitooling "agent-desk/internal/ai/tooling"
|
||||
"agent-desk/internal/models"
|
||||
"agent-desk/internal/pkg/dto"
|
||||
"agent-desk/internal/pkg/dto/request"
|
||||
"agent-desk/internal/pkg/toolx"
|
||||
)
|
||||
|
||||
// BusinessToolExecutor is the write boundary for built-in business tools.
|
||||
// Autonomous mode deliberately does not expose it; deterministic Playbooks
|
||||
// invoke it only after their human-confirm node has completed.
|
||||
var BusinessToolExecutor = newBusinessToolExecutor(aitooling.DefaultRegistry)
|
||||
|
||||
type BusinessToolInput struct {
|
||||
Conversation models.Conversation
|
||||
AIAgent models.AIAgent
|
||||
ToolCode string
|
||||
Arguments map[string]any
|
||||
IdempotencyKey string
|
||||
Confirmed bool
|
||||
}
|
||||
|
||||
type BusinessToolResult struct {
|
||||
Definition aitooling.Definition
|
||||
ResultData string
|
||||
Reused bool
|
||||
}
|
||||
|
||||
type businessToolExecutor struct {
|
||||
registry *aitooling.Registry
|
||||
}
|
||||
|
||||
func newBusinessToolExecutor(registry *aitooling.Registry) *businessToolExecutor {
|
||||
return &businessToolExecutor{registry: registry}
|
||||
}
|
||||
|
||||
func (e *businessToolExecutor) Execute(_ context.Context, input BusinessToolInput) (*BusinessToolResult, error) {
|
||||
toolCode := toolx.NormalizeToolCodeAlias(strings.TrimSpace(input.ToolCode))
|
||||
definition, err := e.registry.Resolve(toolCode)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := e.registry.Authorize(definition, aitooling.Policy{AllowedToolCodes: []string{definition.Code}, AllowedRiskLevels: []string{aitooling.RiskLevelWrite}, Confirmed: input.Confirmed}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if input.Conversation.ID <= 0 || strings.TrimSpace(input.IdempotencyKey) == "" {
|
||||
return nil, fmt.Errorf("business tool invocation requires conversation and idempotency key")
|
||||
}
|
||||
claim, err := AgentToolInvocationService.Claim(input.Conversation.ID, input.AIAgent.ID, definition.Code, input.IdempotencyKey)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if claim == nil || claim.Item == nil {
|
||||
return nil, fmt.Errorf("business tool invocation could not be claimed")
|
||||
}
|
||||
if claim.Completed {
|
||||
return &BusinessToolResult{Definition: definition, ResultData: claim.Item.ResultData, Reused: true}, nil
|
||||
}
|
||||
if !claim.Acquired {
|
||||
return nil, fmt.Errorf("business tool invocation is already running: %s", definition.Code)
|
||||
}
|
||||
|
||||
resultData, err := e.execute(definition.Code, input)
|
||||
if err != nil {
|
||||
_ = AgentToolInvocationService.Fail(claim.Item, err)
|
||||
return nil, err
|
||||
}
|
||||
if err := AgentToolInvocationService.Complete(claim.Item, resultData); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &BusinessToolResult{Definition: definition, ResultData: resultData}, nil
|
||||
}
|
||||
|
||||
func (e *businessToolExecutor) execute(toolCode string, input BusinessToolInput) (string, error) {
|
||||
switch toolCode {
|
||||
case toolx.GraphCreateTicketConfirm.Code:
|
||||
item, err := TicketService.CreateFromConversation(request.CreateTicketFromConversationRequest{
|
||||
ConversationID: input.Conversation.ID,
|
||||
Title: businessToolString(input.Arguments["title"]),
|
||||
Description: businessToolString(input.Arguments["description"]),
|
||||
}, businessToolPrincipal(input.AIAgent))
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return businessToolJSON(map[string]any{"ticketId": item.ID, "ticketNo": item.TicketNo, "created": true})
|
||||
case toolx.GraphHandoffConversation.Code:
|
||||
result, err := ConversationHumanDispatchService.HandoffByAIWithRequestID(input.Conversation.ID, input.AIAgent, businessToolString(input.Arguments["reason"]), input.IdempotencyKey)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return businessToolJSON(map[string]any{"decision": result.Decision, "teamId": result.TeamID, "assigneeId": result.AssigneeID, "message": result.Message})
|
||||
default:
|
||||
return "", fmt.Errorf("business tool is not executable: %s", toolCode)
|
||||
}
|
||||
}
|
||||
|
||||
func businessToolString(value any) string {
|
||||
text, _ := value.(string)
|
||||
return strings.TrimSpace(text)
|
||||
}
|
||||
|
||||
func businessToolPrincipal(agent models.AIAgent) *dto.AuthPrincipal {
|
||||
name := strings.TrimSpace(agent.Name)
|
||||
if name == "" {
|
||||
name = "AI"
|
||||
}
|
||||
return &dto.AuthPrincipal{Username: name, Nickname: name}
|
||||
}
|
||||
|
||||
func businessToolJSON(value any) (string, error) {
|
||||
data, err := json.Marshal(value)
|
||||
return string(data), err
|
||||
}
|
||||
@@ -105,17 +105,49 @@ func (s *channelService) UpdateChannel(req request.UpdateChannelRequest, operato
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return repositories.ChannelRepository.Updates(sqls.DB(), req.ID, map[string]any{
|
||||
"channel_type": item.ChannelType,
|
||||
"channel_id": item.ChannelID,
|
||||
"ai_agent_id": item.AIAgentID,
|
||||
"name": item.Name,
|
||||
"config_json": item.ConfigJSON,
|
||||
"status": item.Status,
|
||||
"remark": item.Remark,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": time.Now(),
|
||||
columns := map[string]any{
|
||||
"channel_type": item.ChannelType,
|
||||
"channel_id": item.ChannelID,
|
||||
"ai_agent_id": item.AIAgentID,
|
||||
"ai_agent_rollout_percent": item.AIAgentRolloutPercent,
|
||||
"name": item.Name,
|
||||
"config_json": item.ConfigJSON,
|
||||
"status": item.Status,
|
||||
"remark": item.Remark,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": time.Now(),
|
||||
}
|
||||
if item.AIAgentRolloutPercent != current.AIAgentRolloutPercent {
|
||||
columns["previous_ai_agent_rollout_percent"] = current.AIAgentRolloutPercent
|
||||
}
|
||||
return repositories.ChannelRepository.Updates(sqls.DB(), req.ID, columns)
|
||||
}
|
||||
|
||||
// RollbackChannelAIAgentRollout restores the last channel-level rollout value
|
||||
// and swaps it into history so the action itself is reversible.
|
||||
func (s *channelService) RollbackChannelAIAgentRollout(id int64, operator *dto.AuthPrincipal) error {
|
||||
if operator == nil {
|
||||
return errorsx.UnauthorizedI18n("error.auth.expired")
|
||||
}
|
||||
if id <= 0 {
|
||||
return errorsx.InvalidParam("channel id is required")
|
||||
}
|
||||
return sqls.WithTransaction(func(ctx *sqls.TxContext) error {
|
||||
channel := repositories.ChannelRepository.Get(ctx.Tx, id)
|
||||
if channel == nil || channel.Status == enums.StatusDeleted {
|
||||
return errorsx.InvalidParamI18n("error.e0208")
|
||||
}
|
||||
if channel.PreviousAIAgentRolloutPercent < 1 || channel.PreviousAIAgentRolloutPercent > 100 {
|
||||
return errorsx.InvalidParam("channel rollout has no previous value to restore")
|
||||
}
|
||||
return repositories.ChannelRepository.Updates(ctx.Tx, channel.ID, map[string]any{
|
||||
"ai_agent_rollout_percent": channel.PreviousAIAgentRolloutPercent,
|
||||
"previous_ai_agent_rollout_percent": channel.AIAgentRolloutPercent,
|
||||
"update_user_id": operator.UserID,
|
||||
"update_user_name": operator.Username,
|
||||
"updated_at": time.Now(),
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
@@ -394,12 +426,30 @@ func (s *channelService) buildChannelModel(id int64, req request.CreateChannelRe
|
||||
if req.AIAgentID <= 0 {
|
||||
return nil, errorsx.InvalidParamI18n("error.e0321")
|
||||
}
|
||||
if req.AIAgentRolloutPercent == 0 {
|
||||
req.AIAgentRolloutPercent = 100
|
||||
}
|
||||
if req.AIAgentRolloutPercent < 1 || req.AIAgentRolloutPercent > 100 {
|
||||
return nil, errorsx.InvalidParam("channel ai agent rollout percent must be between 1 and 100")
|
||||
}
|
||||
aiAgent := AIAgentService.Get(req.AIAgentID)
|
||||
if aiAgent == nil || aiAgent.Status != enums.StatusOk {
|
||||
return nil, errorsx.InvalidParamI18n("error.e0004")
|
||||
}
|
||||
if aiAgent.WorkflowVersionID <= 0 {
|
||||
return nil, errorsx.InvalidParam("ai agent workflow must be published before binding channel")
|
||||
if aiAgent.RuntimeMode == "" || aiAgent.RuntimeMode == enums.AIAgentRuntimeModeWorkflow {
|
||||
if aiAgent.WorkflowVersionID <= 0 {
|
||||
return nil, errorsx.InvalidParam("ai agent workflow must be published before binding channel")
|
||||
}
|
||||
} else if aiAgent.RuntimeMode == enums.AIAgentRuntimeModeAutonomous {
|
||||
if aiAgent.PublishedRevisionID <= 0 {
|
||||
return nil, errorsx.InvalidParam("autonomous ai agent must be published before binding channel")
|
||||
}
|
||||
} else if aiAgent.RuntimeMode == enums.AIAgentRuntimeModeHybrid {
|
||||
if aiAgent.PublishedRevisionID <= 0 || aiAgent.WorkflowVersionID <= 0 {
|
||||
return nil, errorsx.InvalidParam("hybrid ai agent and workflow must be published before binding channel")
|
||||
}
|
||||
} else {
|
||||
return nil, errorsx.InvalidParam("ai agent runtime mode is not available yet")
|
||||
}
|
||||
status := enums.Status(req.Status)
|
||||
if req.Status == 0 {
|
||||
@@ -485,12 +535,13 @@ func (s *channelService) buildChannelModel(id int64, req request.CreateChannelRe
|
||||
}
|
||||
|
||||
return &models.Channel{
|
||||
ChannelType: channelType,
|
||||
ChannelID: channelID,
|
||||
AIAgentID: req.AIAgentID,
|
||||
Name: name,
|
||||
ConfigJSON: configJSON,
|
||||
Status: status,
|
||||
Remark: strings.TrimSpace(req.Remark),
|
||||
ChannelType: channelType,
|
||||
ChannelID: channelID,
|
||||
AIAgentID: req.AIAgentID,
|
||||
AIAgentRolloutPercent: req.AIAgentRolloutPercent,
|
||||
Name: name,
|
||||
ConfigJSON: configJSON,
|
||||
Status: status,
|
||||
Remark: strings.TrimSpace(req.Remark),
|
||||
}, nil
|
||||
}
|
||||
|
||||
@@ -48,6 +48,123 @@ func TestChannelServiceAllowsAgentWithPublishedWorkflow(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelServiceStoresAIAgentRolloutPercent(t *testing.T) {
|
||||
db := setupChannelServiceTestDB(t)
|
||||
agent := createChannelServiceTestAgent(t, db, 1001)
|
||||
item, err := ChannelService.CreateChannel(request.CreateChannelRequest{
|
||||
ChannelType: enums.ChannelTypeWeb, AIAgentID: agent.ID, AIAgentRolloutPercent: 25,
|
||||
Name: "灰度渠道", Status: int(enums.StatusOk),
|
||||
}, channelServiceTestOperator())
|
||||
if err != nil || item == nil || item.AIAgentRolloutPercent != 25 {
|
||||
t.Fatalf("expected persisted rollout percent, item=%#v err=%v", item, err)
|
||||
}
|
||||
if _, err := ChannelService.CreateChannel(request.CreateChannelRequest{
|
||||
ChannelType: enums.ChannelTypeWeb, AIAgentID: agent.ID, AIAgentRolloutPercent: 101,
|
||||
Name: "错误灰度渠道", Status: int(enums.StatusOk),
|
||||
}, channelServiceTestOperator()); err == nil {
|
||||
t.Fatal("expected invalid rollout percent to be rejected")
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelServiceRollsBackPreviousAIAgentRolloutPercent(t *testing.T) {
|
||||
db := setupChannelServiceTestDB(t)
|
||||
agent := createChannelServiceTestAgent(t, db, 1001)
|
||||
channel, err := ChannelService.CreateChannel(request.CreateChannelRequest{
|
||||
ChannelType: enums.ChannelTypeWeb, AIAgentID: agent.ID, AIAgentRolloutPercent: 20,
|
||||
Name: "渠道灰度回滚", Status: int(enums.StatusOk),
|
||||
}, channelServiceTestOperator())
|
||||
if err != nil {
|
||||
t.Fatalf("create channel: %v", err)
|
||||
}
|
||||
if err := db.Model(&models.Channel{}).Where("id = ?", channel.ID).Update("previous_ai_agent_rollout_percent", 100).Error; err != nil {
|
||||
t.Fatalf("set previous rollout: %v", err)
|
||||
}
|
||||
operator := channelServiceTestOperator()
|
||||
if err := ChannelService.RollbackChannelAIAgentRollout(channel.ID, operator); err != nil {
|
||||
t.Fatalf("RollbackChannelAIAgentRollout: %v", err)
|
||||
}
|
||||
updated := ChannelService.Get(channel.ID)
|
||||
if updated == nil || updated.AIAgentRolloutPercent != 100 || updated.PreviousAIAgentRolloutPercent != 20 {
|
||||
t.Fatalf("unexpected channel rollout rollback: %#v", updated)
|
||||
}
|
||||
if err := ChannelService.RollbackChannelAIAgentRollout(channel.ID, operator); err != nil {
|
||||
t.Fatalf("second RollbackChannelAIAgentRollout: %v", err)
|
||||
}
|
||||
updated = ChannelService.Get(channel.ID)
|
||||
if updated == nil || updated.AIAgentRolloutPercent != 20 || updated.PreviousAIAgentRolloutPercent != 100 {
|
||||
t.Fatalf("unexpected channel rollout redo: %#v", updated)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelServiceRejectsUnpublishedAutonomousRuntime(t *testing.T) {
|
||||
db := setupChannelServiceTestDB(t)
|
||||
agent := createChannelServiceTestAgent(t, db, 1001)
|
||||
if err := db.Model(&models.AIAgent{}).Where("id = ?", agent.ID).Update("runtime_mode", enums.AIAgentRuntimeModeAutonomous).Error; err != nil {
|
||||
t.Fatalf("set autonomous runtime mode: %v", err)
|
||||
}
|
||||
|
||||
_, err := ChannelService.CreateChannel(request.CreateChannelRequest{
|
||||
ChannelType: enums.ChannelTypeWeb,
|
||||
AIAgentID: agent.ID,
|
||||
Name: "官网客服",
|
||||
Status: int(enums.StatusOk),
|
||||
}, channelServiceTestOperator())
|
||||
if err == nil || !strings.Contains(err.Error(), "must be published") {
|
||||
t.Fatalf("expected unpublished autonomous runtime error, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelServiceAcceptsPublishedAutonomousRuntime(t *testing.T) {
|
||||
db := setupChannelServiceTestDB(t)
|
||||
agent := createChannelServiceTestAgent(t, db, 1001)
|
||||
revision := &models.AgentRevision{AgentID: agent.ID, Revision: 1, Status: enums.StatusOk}
|
||||
if err := db.Create(revision).Error; err != nil {
|
||||
t.Fatalf("create agent revision: %v", err)
|
||||
}
|
||||
if err := db.Model(&models.AIAgent{}).Where("id = ?", agent.ID).Updates(map[string]any{
|
||||
"runtime_mode": enums.AIAgentRuntimeModeAutonomous,
|
||||
"published_revision_id": revision.ID,
|
||||
}).Error; err != nil {
|
||||
t.Fatalf("set autonomous runtime mode: %v", err)
|
||||
}
|
||||
item, err := ChannelService.CreateChannel(request.CreateChannelRequest{
|
||||
ChannelType: enums.ChannelTypeWeb, AIAgentID: agent.ID, Name: "自主客服", Status: int(enums.StatusOk),
|
||||
}, channelServiceTestOperator())
|
||||
if err != nil || item == nil {
|
||||
t.Fatalf("create channel for autonomous runtime: item=%#v err=%v", item, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestChannelServiceRequiresBothHybridPublicationArtifacts(t *testing.T) {
|
||||
db := setupChannelServiceTestDB(t)
|
||||
agent := createChannelServiceTestAgent(t, db, 0)
|
||||
revision := &models.AgentRevision{AgentID: agent.ID, Revision: 1, Status: enums.StatusOk}
|
||||
if err := db.Create(revision).Error; err != nil {
|
||||
t.Fatalf("create agent revision: %v", err)
|
||||
}
|
||||
if err := db.Model(&models.AIAgent{}).Where("id = ?", agent.ID).Updates(map[string]any{
|
||||
"runtime_mode": enums.AIAgentRuntimeModeHybrid,
|
||||
"published_revision_id": revision.ID,
|
||||
}).Error; err != nil {
|
||||
t.Fatalf("set hybrid runtime mode: %v", err)
|
||||
}
|
||||
_, err := ChannelService.CreateChannel(request.CreateChannelRequest{
|
||||
ChannelType: enums.ChannelTypeWeb, AIAgentID: agent.ID, Name: "混合客服", Status: int(enums.StatusOk),
|
||||
}, channelServiceTestOperator())
|
||||
if err == nil || !strings.Contains(err.Error(), "hybrid ai agent") {
|
||||
t.Fatalf("expected hybrid publication error, got %v", err)
|
||||
}
|
||||
if err := db.Model(&models.AIAgent{}).Where("id = ?", agent.ID).Update("workflow_version_id", 1001).Error; err != nil {
|
||||
t.Fatalf("set workflow version: %v", err)
|
||||
}
|
||||
item, err := ChannelService.CreateChannel(request.CreateChannelRequest{
|
||||
ChannelType: enums.ChannelTypeWeb, AIAgentID: agent.ID, Name: "混合客服已发布", Status: int(enums.StatusOk),
|
||||
}, channelServiceTestOperator())
|
||||
if err != nil || item == nil {
|
||||
t.Fatalf("create channel for hybrid runtime: item=%#v err=%v", item, err)
|
||||
}
|
||||
}
|
||||
|
||||
func setupChannelServiceTestDB(t *testing.T) *gorm.DB {
|
||||
t.Helper()
|
||||
dbName := strings.NewReplacer("/", "_", " ", "_").Replace(t.Name())
|
||||
@@ -66,7 +183,7 @@ func setupChannelServiceTestDB(t *testing.T) *gorm.DB {
|
||||
_ = sqlDB.Close()
|
||||
}
|
||||
})
|
||||
if err := db.AutoMigrate(&models.AIAgent{}, &models.Channel{}); err != nil {
|
||||
if err := db.AutoMigrate(&models.AIAgent{}, &models.AgentRevision{}, &models.Channel{}); err != nil {
|
||||
t.Fatalf("auto migrate: %v", err)
|
||||
}
|
||||
sqls.SetDB(db)
|
||||
|
||||
@@ -94,6 +94,8 @@ func (s *conversationInterruptService) mergeForCheckpointUpdate(current, next *m
|
||||
merged := *current
|
||||
merged.ConversationID = current.ConversationID
|
||||
merged.AIAgentID = current.AIAgentID
|
||||
merged.AgentRunID = current.AgentRunID
|
||||
merged.AgentStepID = current.AgentStepID
|
||||
merged.SourceMessageID = current.SourceMessageID
|
||||
merged.LastResumeMessageID = current.LastResumeMessageID
|
||||
merged.WorkflowRunID = current.WorkflowRunID
|
||||
@@ -120,6 +122,8 @@ func (s *conversationInterruptService) mergeForPendingUpdate(current, next *mode
|
||||
merged := *current
|
||||
merged.ConversationID = next.ConversationID
|
||||
merged.AIAgentID = next.AIAgentID
|
||||
merged.AgentRunID = next.AgentRunID
|
||||
merged.AgentStepID = next.AgentStepID
|
||||
merged.SourceMessageID = next.SourceMessageID
|
||||
merged.WorkflowRunID = next.WorkflowRunID
|
||||
merged.WorkflowNodeID = next.WorkflowNodeID
|
||||
|
||||
Reference in New Issue
Block a user