wlw/ai-agent
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add AI workflow service foundation

Browse Source
This commit is contained in:
mlogclub
2026-06-22 00:11:26 +08:00
parent fa99c5bed9
commit 0127455be5
10 changed files with 807 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/builders/ai_workflow_builder.go
+94
View File
@@ -0,0 +1,94 @@
package builders
import (
"encoding/json"
"agent-desk/internal/ai/workflow/dsl"
workflowregistry "agent-desk/internal/ai/workflow/registry"
"agent-desk/internal/models"
"agent-desk/internal/pkg/dto/response"
)
func BuildAIWorkflow(item *models.AIWorkflow) response.AIWorkflowResponse {
if item == nil {
return response.AIWorkflowResponse{}
}
return response.AIWorkflowResponse{
ID: item.ID,
Name: item.Name,
Description: item.Description,
OwnerType: item.OwnerType,
OwnerID: item.OwnerID,
Status: item.Status,
DraftDefinition: parseWorkflowDefinition(item.DraftDefinition),
PublishedVersionID: item.PublishedVersionID,
SortNo: item.SortNo,
CreatedAt: item.CreatedAt.Format("2006-01-02 15:04:05"),
UpdatedAt: item.UpdatedAt.Format("2006-01-02 15:04:05"),
CreateUserName: item.CreateUserName,
UpdateUserName: item.UpdateUserName,
}
}
func BuildAIWorkflowList(list []models.AIWorkflow) []response.AIWorkflowResponse {
ret := make([]response.AIWorkflowResponse, 0, len(list))
for i := range list {
ret = append(ret, BuildAIWorkflow(&list[i]))
}
return ret
}
func BuildAIWorkflowVersion(item *models.AIWorkflowVersion) response.AIWorkflowVersionResponse {
if item == nil {
return response.AIWorkflowVersionResponse{}
}
publishedAt := ""
if item.PublishedAt != nil {
publishedAt = item.PublishedAt.Format("2006-01-02 15:04:05")
}
return response.AIWorkflowVersionResponse{
ID: item.ID,
WorkflowID: item.WorkflowID,
Version: item.Version,
Status: item.Status,
Definition: parseWorkflowDefinition(item.Definition),
DefinitionHash: item.DefinitionHash,
PublishedAt: publishedAt,
PublishedByID: item.PublishedByID,
PublishedByName: item.PublishedByName,
CreatedAt: item.CreatedAt.Format("2006-01-02 15:04:05"),
UpdatedAt: item.UpdatedAt.Format("2006-01-02 15:04:05"),
}
}
func BuildAIWorkflowVersionList(list []models.AIWorkflowVersion) []response.AIWorkflowVersionResponse {
ret := make([]response.AIWorkflowVersionResponse, 0, len(list))
for i := range list {
ret = append(ret, BuildAIWorkflowVersion(&list[i]))
}
return ret
}
func BuildAIWorkflowNodeSpecs(list []workflowregistry.NodeSpec) []response.AIWorkflowNodeSpecResponse {
ret := make([]response.AIWorkflowNodeSpecResponse, 0, len(list))
for _, item := range list {
ret = append(ret, response.AIWorkflowNodeSpecResponse{
Type: item.Type,
Title: item.Title,
Description: item.Description,
RiskLevel: item.RiskLevel,
Interruptible: item.Interruptible,
RequiresConfirmationPredecessor: item.RequiresConfirmationPredecessor,
})
}
return ret
}
func parseWorkflowDefinition(raw string) dsl.Definition {
var ret dsl.Definition
if raw == "" {
return ret
}
_ = json.Unmarshal([]byte(raw), &ret)
return ret
}
internal/models/models.go
+64
View File
@@ -58,6 +58,10 @@ var Models = []any{
&SkillDefinition{},
&SkillRunLog{},
&AgentRunLog{},
&AIWorkflow{},
&AIWorkflowVersion{},
&AIWorkflowRun{},
&AIWorkflowNodeRun{},
&ConversationInterrupt{},
&SystemConfig{},
}
@@ -527,6 +531,66 @@ type AIAgent struct {
AuditFields
}
// AIWorkflow 表示客服 AI Agent 可编辑会话流程主表。
type AIWorkflow struct {
ID int64 `gorm:"primaryKey;autoIncrement"`
Name string `gorm:"type:varchar(100);not null;default:'';index"`
Description string `gorm:"type:text"`
OwnerType string `gorm:"type:varchar(30);not null;default:'';index"`
OwnerID int64 `gorm:"type:bigint;not null;default:0;index"`
Status enums.Status `gorm:"type:int;not null;default:0;index"`
DraftDefinition string `gorm:"type:longtext"`
PublishedVersionID int64 `gorm:"type:bigint;not null;default:0;index"`
SortNo int `gorm:"type:int;not null;default:0;index"`
AuditFields
}
// AIWorkflowVersion 表示 AI 会话流程的不可变发布版本。
type AIWorkflowVersion struct {
ID int64 `gorm:"primaryKey;autoIncrement"`
WorkflowID int64 `gorm:"type:bigint;not null;default:0;index"`
Version int `gorm:"type:int;not null;default:0;index"`
Status enums.Status `gorm:"type:int;not null;default:0;index"`
Definition string `gorm:"type:longtext"`
DefinitionHash string `gorm:"type:varchar(64);not null;default:'';index"`
PublishedAt *time.Time `gorm:"type:datetime;index"`
PublishedByID int64 `gorm:"type:bigint;not null;default:0;index"`
PublishedByName string `gorm:"type:varchar(100);not null;default:''"`
AuditFields
}
// AIWorkflowRun 表示一次会话 workflow 执行记录。
type AIWorkflowRun struct {
ID int64 `gorm:"primaryKey;autoIncrement"`
WorkflowID int64 `gorm:"type:bigint;not null;default:0;index"`
WorkflowVersionID int64 `gorm:"type:bigint;not null;default:0;index"`
ConversationID int64 `gorm:"type:bigint;not null;default:0;index"`
AIAgentID int64 `gorm:"type:bigint;not null;default:0;index"`
MessageID int64 `gorm:"type:bigint;not null;default:0;index"`
Status int `gorm:"type:int;not null;default:0;index"`
StartedAt time.Time `gorm:"type:datetime;not null;index"`
EndedAt *time.Time `gorm:"type:datetime;index"`
InterruptType string `gorm:"type:varchar(50);not null;default:'';index"`
InterruptNodeID string `gorm:"type:varchar(100);not null;default:'';index"`
ErrorMessage string `gorm:"type:text"`
AuditFields
}
// AIWorkflowNodeRun 表示 workflow 执行中的单节点审计记录。
type AIWorkflowNodeRun struct {
ID int64 `gorm:"primaryKey;autoIncrement"`
WorkflowRunID int64 `gorm:"type:bigint;not null;default:0;index"`
NodeID string `gorm:"type:varchar(100);not null;default:'';index"`
NodeType string `gorm:"type:varchar(50);not null;default:'';index"`
Status int `gorm:"type:int;not null;default:0;index"`
InputPreview string `gorm:"type:text"`
OutputPreview string `gorm:"type:text"`
ErrorMessage string `gorm:"type:text"`
StartedAt time.Time `gorm:"type:datetime;not null;index"`
EndedAt *time.Time `gorm:"type:datetime;index"`
DurationMS int `gorm:"type:int;not null;default:0"`
}
// Channel 接入渠道配置。
//
// 用于统一描述系统的外部接入入口。不同渠道类型共享统一的接入配置骨架，
internal/pkg/dto/request/ai_workflow_request.go
+33
View File
@@ -0,0 +1,33 @@
package request
import "agent-desk/internal/ai/workflow/dsl"
type CreateAIWorkflowRequest struct {
Name string `json:"name"`
Description string `json:"description"`
OwnerType string `json:"ownerType"`
OwnerID int64 `json:"ownerId"`
Definition dsl.Definition `json:"definition"`
}
type UpdateAIWorkflowRequest struct {
ID int64 `json:"id"`
CreateAIWorkflowRequest
}
type DeleteAIWorkflowRequest struct {
ID int64 `json:"id"`
}
type ValidateAIWorkflowRequest struct {
Definition dsl.Definition `json:"definition"`
}
type PublishAIWorkflowRequest struct {
WorkflowID int64 `json:"workflowId"`
Definition dsl.Definition `json:"definition"`
}
type AIWorkflowVersionListRequest struct {
WorkflowID int64 `json:"workflowId"`
}
internal/pkg/dto/response/ai_workflow_response.go
+52
View File
@@ -0,0 +1,52 @@
package response
import (
"agent-desk/internal/ai/workflow/dsl"
workflowregistry "agent-desk/internal/ai/workflow/registry"
workflowvalidator "agent-desk/internal/ai/workflow/validator"
"agent-desk/internal/pkg/enums"
)
type AIWorkflowResponse struct {
ID int64 `json:"id"`
Name string `json:"name"`
Description string `json:"description"`
OwnerType string `json:"ownerType"`
OwnerID int64 `json:"ownerId"`
Status enums.Status `json:"status"`
DraftDefinition dsl.Definition `json:"draftDefinition"`
PublishedVersionID int64 `json:"publishedVersionId"`
SortNo int `json:"sortNo"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
CreateUserName string `json:"createUserName"`
UpdateUserName string `json:"updateUserName"`
}
type AIWorkflowVersionResponse struct {
ID int64 `json:"id"`
WorkflowID int64 `json:"workflowId"`
Version int `json:"version"`
Status enums.Status `json:"status"`
Definition dsl.Definition `json:"definition"`
DefinitionHash string `json:"definitionHash"`
PublishedAt string `json:"publishedAt"`
PublishedByID int64 `json:"publishedById"`
PublishedByName string `json:"publishedByName"`
CreatedAt string `json:"createdAt"`
UpdatedAt string `json:"updatedAt"`
}
type AIWorkflowValidationResponse struct {
Valid bool `json:"valid"`
Errors []workflowvalidator.Error `json:"errors"`
}
type AIWorkflowNodeSpecResponse struct {
Type string `json:"type"`
Title string `json:"title"`
Description string `json:"description"`
RiskLevel workflowregistry.NodeRiskLevel `json:"riskLevel"`
Interruptible bool `json:"interruptible"`
RequiresConfirmationPredecessor bool `json:"requiresConfirmationPredecessor"`
}
internal/repositories/ai_workflow_node_run_repository.go
+37
View File
@@ -0,0 +1,37 @@
package repositories
import (
"agent-desk/internal/models"
"github.com/mlogclub/simple/sqls"
"gorm.io/gorm"
)
var AIWorkflowNodeRunRepository = newAIWorkflowNodeRunRepository()
func newAIWorkflowNodeRunRepository() *aiWorkflowNodeRunRepository {
return &aiWorkflowNodeRunRepository{}
}
type aiWorkflowNodeRunRepository struct{}
func (r *aiWorkflowNodeRunRepository) Get(db *gorm.DB, id int64) *models.AIWorkflowNodeRun {
ret := &models.AIWorkflowNodeRun{}
if err := db.First(ret, "id = ?", id).Error; err != nil {
return nil
}
return ret
}
func (r *aiWorkflowNodeRunRepository) Find(db *gorm.DB, cnd *sqls.Cnd) (list []models.AIWorkflowNodeRun) {
cnd.Find(db, &list)
return
}
func (r *aiWorkflowNodeRunRepository) Create(db *gorm.DB, t *models.AIWorkflowNodeRun) error {
return db.Create(t).Error
}
func (r *aiWorkflowNodeRunRepository) Updates(db *gorm.DB, id int64, columns map[string]interface{}) error {
return db.Model(&models.AIWorkflowNodeRun{}).Where("id = ?", id).Updates(columns).Error
}
internal/repositories/ai_workflow_repository.go
+61
View File
@@ -0,0 +1,61 @@
package repositories
import (
"agent-desk/internal/models"
"agent-desk/internal/pkg/httpx/params"
"github.com/mlogclub/simple/sqls"
"gorm.io/gorm"
)
var AIWorkflowRepository = newAIWorkflowRepository()
func newAIWorkflowRepository() *aiWorkflowRepository {
return &aiWorkflowRepository{}
}
type aiWorkflowRepository struct{}
func (r *aiWorkflowRepository) Get(db *gorm.DB, id int64) *models.AIWorkflow {
ret := &models.AIWorkflow{}
if err := db.First(ret, "id = ?", id).Error; err != nil {
return nil
}
return ret
}
func (r *aiWorkflowRepository) Take(db *gorm.DB, where ...interface{}) *models.AIWorkflow {
ret := &models.AIWorkflow{}
if err := db.Take(ret, where...).Error; err != nil {
return nil
}
return ret
}
func (r *aiWorkflowRepository) Find(db *gorm.DB, cnd *sqls.Cnd) (list []models.AIWorkflow) {
cnd.Find(db, &list)
return
}
func (r *aiWorkflowRepository) FindPageByParams(db *gorm.DB, params *params.QueryParams) (list []models.AIWorkflow, paging *sqls.Paging) {
return r.FindPageByCnd(db, &params.Cnd)
}
func (r *aiWorkflowRepository) FindPageByCnd(db *gorm.DB, cnd *sqls.Cnd) (list []models.AIWorkflow, paging *sqls.Paging) {
cnd.Find(db, &list)
count := cnd.Count(db, &models.AIWorkflow{})
paging = &sqls.Paging{
Page: cnd.Paging.Page,
Limit: cnd.Paging.Limit,
Total: count,
}
return
}
func (r *aiWorkflowRepository) Create(db *gorm.DB, t *models.AIWorkflow) error {
return db.Create(t).Error
}
func (r *aiWorkflowRepository) Updates(db *gorm.DB, id int64, columns map[string]interface{}) error {
return db.Model(&models.AIWorkflow{}).Where("id = ?", id).Updates(columns).Error
}
internal/repositories/ai_workflow_run_repository.go
+37
View File
@@ -0,0 +1,37 @@
package repositories
import (
"agent-desk/internal/models"
"github.com/mlogclub/simple/sqls"
"gorm.io/gorm"
)
var AIWorkflowRunRepository = newAIWorkflowRunRepository()
func newAIWorkflowRunRepository() *aiWorkflowRunRepository {
return &aiWorkflowRunRepository{}
}
type aiWorkflowRunRepository struct{}
func (r *aiWorkflowRunRepository) Get(db *gorm.DB, id int64) *models.AIWorkflowRun {
ret := &models.AIWorkflowRun{}
if err := db.First(ret, "id = ?", id).Error; err != nil {
return nil
}
return ret
}
func (r *aiWorkflowRunRepository) Find(db *gorm.DB, cnd *sqls.Cnd) (list []models.AIWorkflowRun) {
cnd.Find(db, &list)
return
}
func (r *aiWorkflowRunRepository) Create(db *gorm.DB, t *models.AIWorkflowRun) error {
return db.Create(t).Error
}
func (r *aiWorkflowRunRepository) Updates(db *gorm.DB, id int64, columns map[string]interface{}) error {
return db.Model(&models.AIWorkflowRun{}).Where("id = ?", id).Updates(columns).Error
}
internal/repositories/ai_workflow_version_repository.go
+58
View File
@@ -0,0 +1,58 @@
package repositories
import (
"agent-desk/internal/models"
"agent-desk/internal/pkg/httpx/params"
"github.com/mlogclub/simple/sqls"
"gorm.io/gorm"
)
var AIWorkflowVersionRepository = newAIWorkflowVersionRepository()
func newAIWorkflowVersionRepository() *aiWorkflowVersionRepository {
return &aiWorkflowVersionRepository{}
}
type aiWorkflowVersionRepository struct{}
func (r *aiWorkflowVersionRepository) Get(db *gorm.DB, id int64) *models.AIWorkflowVersion {
ret := &models.AIWorkflowVersion{}
if err := db.First(ret, "id = ?", id).Error; err != nil {
return nil
}
return ret
}
func (r *aiWorkflowVersionRepository) Find(db *gorm.DB, cnd *sqls.Cnd) (list []models.AIWorkflowVersion) {
cnd.Find(db, &list)
return
}
func (r *aiWorkflowVersionRepository) FindPageByParams(db *gorm.DB, params *params.QueryParams) (list []models.AIWorkflowVersion, paging *sqls.Paging) {
return r.FindPageByCnd(db, &params.Cnd)
}
func (r *aiWorkflowVersionRepository) FindPageByCnd(db *gorm.DB, cnd *sqls.Cnd) (list []models.AIWorkflowVersion, paging *sqls.Paging) {
cnd.Find(db, &list)
count := cnd.Count(db, &models.AIWorkflowVersion{})
paging = &sqls.Paging{
Page: cnd.Paging.Page,
Limit: cnd.Paging.Limit,
Total: count,
}
return
}
func (r *aiWorkflowVersionRepository) Create(db *gorm.DB, t *models.AIWorkflowVersion) error {
return db.Create(t).Error
}
func (r *aiWorkflowVersionRepository) MaxVersionByWorkflowID(db *gorm.DB, workflowID int64) int {
var maxVersion int
db.Model(&models.AIWorkflowVersion{}).
Where("workflow_id = ?", workflowID).
Select("COALESCE(MAX(version), 0)").
Scan(&maxVersion)
return maxVersion
}
internal/services/ai_workflow_service.go
+219
View File
@@ -0,0 +1,219 @@
package services
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"strings"
"time"
"agent-desk/internal/ai/workflow/dsl"
workflowregistry "agent-desk/internal/ai/workflow/registry"
workflowvalidator "agent-desk/internal/ai/workflow/validator"
"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"
)
var AIWorkflowService = newAIWorkflowService()
func newAIWorkflowService() *aiWorkflowService {
return &aiWorkflowService{
registry: workflowregistry.DefaultRegistry(),
}
}
type aiWorkflowService struct {
registry *workflowregistry.Registry
}
func (s *aiWorkflowService) Get(id int64) *models.AIWorkflow {
if id <= 0 {
return nil
}
return repositories.AIWorkflowRepository.Get(sqls.DB(), id)
}
func (s *aiWorkflowService) GetVersion(id int64) *models.AIWorkflowVersion {
if id <= 0 {
return nil
}
return repositories.AIWorkflowVersionRepository.Get(sqls.DB(), id)
}
func (s *aiWorkflowService) FindPageByCnd(cnd *sqls.Cnd) (list []models.AIWorkflow, paging *sqls.Paging) {
return repositories.AIWorkflowRepository.FindPageByCnd(sqls.DB(), cnd)
}
func (s *aiWorkflowService) FindVersionPageByParams(params *params.QueryParams) (list []models.AIWorkflowVersion, paging *sqls.Paging) {
return repositories.AIWorkflowVersionRepository.FindPageByParams(sqls.DB(), params)
}
func (s *aiWorkflowService) ListNodeSpecs() []workflowregistry.NodeSpec {
return s.registry.List()
}
func (s *aiWorkflowService) ValidateDefinition(def dsl.Definition) workflowvalidator.Result {
return workflowvalidator.ValidateDefinition(def, s.registry)
}
func (s *aiWorkflowService) CreateWorkflow(req request.CreateAIWorkflowRequest, operator *dto.AuthPrincipal) (*models.AIWorkflow, error) {
if operator == nil {
return nil, errorsx.UnauthorizedI18n("error.auth.expired")
}
name := strings.TrimSpace(req.Name)
if name == "" {
return nil, errorsx.InvalidParam("workflow name is required")
}
ownerType := normalizeWorkflowOwnerType(req.OwnerType)
if ownerType == "" {
return nil, errorsx.InvalidParam("workflow owner type is required")
}
if req.OwnerID <= 0 {
return nil, errorsx.InvalidParam("workflow owner id is required")
}
definition, err := marshalDefinition(req.Definition)
if err != nil {
return nil, err
}
item := &models.AIWorkflow{
Name: name,
Description: strings.TrimSpace(req.Description),
OwnerType: ownerType,
OwnerID: req.OwnerID,
Status: enums.StatusOk,
DraftDefinition: definition,
AuditFields: utils.BuildAuditFields(operator),
}
if err := repositories.AIWorkflowRepository.Create(sqls.DB(), item); err != nil {
return nil, err
}
return item, nil
}
func (s *aiWorkflowService) UpdateWorkflow(req request.UpdateAIWorkflowRequest, operator *dto.AuthPrincipal) error {
if operator == nil {
return errorsx.UnauthorizedI18n("error.auth.expired")
}
if s.Get(req.ID) == nil {
return errorsx.InvalidParamI18n("error.e0002")
}
name := strings.TrimSpace(req.Name)
if name == "" {
return errorsx.InvalidParam("workflow name is required")
}
ownerType := normalizeWorkflowOwnerType(req.OwnerType)
if ownerType == "" {
return errorsx.InvalidParam("workflow owner type is required")
}
if req.OwnerID <= 0 {
return errorsx.InvalidParam("workflow owner id is required")
}
definition, err := marshalDefinition(req.Definition)
if err != nil {
return err
}
return repositories.AIWorkflowRepository.Updates(sqls.DB(), req.ID, map[string]interface{}{
"name": name,
"description": strings.TrimSpace(req.Description),
"owner_type": ownerType,
"owner_id": req.OwnerID,
"draft_definition": definition,
"update_user_id": operator.UserID,
"update_user_name": operator.Username,
"updated_at": time.Now(),
})
}
func (s *aiWorkflowService) DeleteWorkflow(id int64, operator *dto.AuthPrincipal) error {
if operator == nil {
return errorsx.UnauthorizedI18n("error.auth.expired")
}
if s.Get(id) == nil {
return errorsx.InvalidParamI18n("error.e0002")
}
return repositories.AIWorkflowRepository.Updates(sqls.DB(), id, map[string]interface{}{
"status": enums.StatusDeleted,
"update_user_id": operator.UserID,
"update_user_name": operator.Username,
"updated_at": time.Now(),
})
}
func (s *aiWorkflowService) PublishWorkflow(req request.PublishAIWorkflowRequest, operator *dto.AuthPrincipal) (*models.AIWorkflowVersion, error) {
if operator == nil {
return nil, errorsx.UnauthorizedI18n("error.auth.expired")
}
workflow := s.Get(req.WorkflowID)
if workflow == nil || workflow.Status == enums.StatusDeleted {
return nil, errorsx.InvalidParamI18n("error.e0002")
}
result := s.ValidateDefinition(req.Definition)
if !result.Valid {
return nil, errorsx.InvalidParam("workflow definition is invalid")
}
definition, err := marshalDefinition(req.Definition)
if err != nil {
return nil, err
}
now := time.Now()
var version *models.AIWorkflowVersion
err = sqls.WithTransaction(func(ctx *sqls.TxContext) error {
nextVersion := repositories.AIWorkflowVersionRepository.MaxVersionByWorkflowID(ctx.Tx, req.WorkflowID) + 1
version = &models.AIWorkflowVersion{
WorkflowID: req.WorkflowID,
Version: nextVersion,
Status: enums.StatusOk,
Definition: definition,
DefinitionHash: hashDefinition(definition),
PublishedAt: &now,
PublishedByID: operator.UserID,
PublishedByName: operator.Username,
AuditFields: utils.BuildAuditFields(operator),
}
if err := repositories.AIWorkflowVersionRepository.Create(ctx.Tx, version); err != nil {
return err
}
return repositories.AIWorkflowRepository.Updates(ctx.Tx, req.WorkflowID, map[string]interface{}{
"draft_definition": definition,
"published_version_id": version.ID,
"update_user_id": operator.UserID,
"update_user_name": operator.Username,
"updated_at": now,
})
})
if err != nil {
return nil, err
}
return version, nil
}
func marshalDefinition(def dsl.Definition) (string, error) {
buf, err := json.Marshal(def)
if err != nil {
return "", errorsx.InvalidParam("invalid workflow definition")
}
return string(buf), nil
}
func hashDefinition(definition string) string {
sum := sha256.Sum256([]byte(definition))
return hex.EncodeToString(sum[:])
}
func normalizeWorkflowOwnerType(ownerType string) string {
ownerType = strings.TrimSpace(ownerType)
switch ownerType {
case "ai_agent", "workspace":
return ownerType
default:
return ""
}
}
internal/services/ai_workflow_service_test.go
+152
View File
@@ -0,0 +1,152 @@
package services
import (
"encoding/json"
"testing"
"agent-desk/internal/ai/workflow/dsl"
"agent-desk/internal/models"
"agent-desk/internal/pkg/dto"
"agent-desk/internal/pkg/dto/request"
"github.com/glebarez/sqlite"
"github.com/mlogclub/simple/sqls"
"gorm.io/gorm"
)
func TestAIWorkflowServiceValidateDefinitionReportsErrors(t *testing.T) {
setupAIWorkflowTestDB(t)
result := AIWorkflowService.ValidateDefinition(dsl.Definition{
SchemaVersion: 1,
EntryNodeID: "start_1",
Nodes: []dsl.Node{
{ID: "start_1", Type: "start"},
{ID: "create_1", Type: "create_ticket"},
{ID: "end_1", Type: "end"},
},
Edges: []dsl.Edge{
{ID: "e1", Source: "start_1", Target: "create_1"},
{ID: "e2", Source: "create_1", Target: "end_1"},
},
})
if result.Valid {
t.Fatalf("expected invalid workflow definition")
}
if len(result.Errors) == 0 {
t.Fatalf("expected validation errors")
}
}
func TestAIWorkflowServicePublishCreatesImmutableVersion(t *testing.T) {
setupAIWorkflowTestDB(t)
operator := aiWorkflowTestOperator()
workflow, err := AIWorkflowService.CreateWorkflow(request.CreateAIWorkflowRequest{
Name: "support flow",
Description: "customer service flow",
OwnerType: "ai_agent",
OwnerID: 12,
Definition: validAIWorkflowDefinition(),
}, operator)
if err != nil {
t.Fatalf("CreateWorkflow() error = %v", err)
}
version, err := AIWorkflowService.PublishWorkflow(request.PublishAIWorkflowRequest{
WorkflowID: workflow.ID,
Definition: validAIWorkflowDefinition(),
}, operator)
if err != nil {
t.Fatalf("PublishWorkflow() error = %v", err)
}
if version.WorkflowID != workflow.ID {
t.Fatalf("expected workflow id %d, got %d", workflow.ID, version.WorkflowID)
}
if version.Version != 1 {
t.Fatalf("expected first version to be 1, got %d", version.Version)
}
if version.DefinitionHash == "" {
t.Fatalf("expected definition hash")
}
if version.PublishedAt == nil {
t.Fatalf("expected published timestamp")
}
var stored dsl.Definition
if err := json.Unmarshal([]byte(version.Definition), &stored); err != nil {
t.Fatalf("unmarshal stored definition: %v", err)
}
if stored.EntryNodeID != "start_1" {
t.Fatalf("unexpected stored definition: %+v", stored)
}
}
func TestAIWorkflowServicePublishIncrementsVersion(t *testing.T) {
setupAIWorkflowTestDB(t)
operator := aiWorkflowTestOperator()
workflow, err := AIWorkflowService.CreateWorkflow(request.CreateAIWorkflowRequest{
Name: "support flow versions",
OwnerType: "ai_agent",
OwnerID: 99,
Definition: validAIWorkflowDefinition(),
}, operator)
if err != nil {
t.Fatalf("CreateWorkflow() error = %v", err)
}
first, err := AIWorkflowService.PublishWorkflow(request.PublishAIWorkflowRequest{
WorkflowID: workflow.ID,
Definition: validAIWorkflowDefinition(),
}, operator)
if err != nil {
t.Fatalf("PublishWorkflow() first error = %v", err)
}
second, err := AIWorkflowService.PublishWorkflow(request.PublishAIWorkflowRequest{
WorkflowID: workflow.ID,
Definition: validAIWorkflowDefinition(),
}, operator)
if err != nil {
t.Fatalf("PublishWorkflow() second error = %v", err)
}
if first.Version != 1 || second.Version != 2 {
t.Fatalf("expected versions 1 and 2, got %d and %d", first.Version, second.Version)
}
}
func setupAIWorkflowTestDB(t *testing.T) {
t.Helper()
db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})
if err != nil {
t.Fatalf("open sqlite db: %v", err)
}
if err := db.AutoMigrate(&models.AIWorkflow{}, &models.AIWorkflowVersion{}, &models.AIWorkflowRun{}, &models.AIWorkflowNodeRun{}); err != nil {
t.Fatalf("auto migrate: %v", err)
}
sqls.SetDB(db)
}
func validAIWorkflowDefinition() dsl.Definition {
return dsl.Definition{
SchemaVersion: 1,
EntryNodeID: "start_1",
Nodes: []dsl.Node{
{ID: "start_1", Type: "start"},
{ID: "reply_1", Type: "send_reply", Config: json.RawMessage(`{"text":"hello"}`)},
{ID: "end_1", Type: "end"},
},
Edges: []dsl.Edge{
{ID: "e1", Source: "start_1", Target: "reply_1"},
{ID: "e2", Source: "reply_1", Target: "end_1"},
},
}
}
func aiWorkflowTestOperator() *dto.AuthPrincipal {
return &dto.AuthPrincipal{
UserID: 1,
Username: "workflow-tester",
Nickname: "workflow-tester",
}
}