2290 lines
84 KiB
Go
2290 lines
84 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"crypto/rand"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"mime/multipart"
|
||
"os"
|
||
"path/filepath"
|
||
"regexp"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
"unicode/utf8"
|
||
|
||
"infinite-canvas/backend/internal/model"
|
||
"infinite-canvas/backend/internal/repository"
|
||
)
|
||
|
||
type Service struct {
|
||
repo *repository.Repository
|
||
dataDir string
|
||
runtimeCapabilities RuntimeCapabilities
|
||
cancelMu sync.Mutex
|
||
registrationMu sync.Mutex
|
||
emailCodeMu sync.Mutex
|
||
redeemBatchMu sync.Mutex
|
||
storageMu sync.Mutex
|
||
characterTaskMu sync.Mutex
|
||
activeCancels map[string]context.CancelFunc
|
||
pendingStorage map[string]int64
|
||
coordinator *runtimeCoordinator
|
||
runtimeErr error
|
||
workerID string
|
||
routeCatalogMu sync.RWMutex
|
||
routeCatalogRefreshMu sync.Mutex
|
||
routeCatalog *routeCatalogSnapshot
|
||
routeCatalogTTL time.Duration
|
||
routeCatalogMaxStale time.Duration
|
||
routeCatalogVersion int64
|
||
routeHealthMu sync.Mutex
|
||
routeHealthBlocked map[string]time.Time
|
||
}
|
||
|
||
const taskWorkerConcurrency = 3
|
||
const taskLogPayloadLimit = 4000
|
||
|
||
type CreateSessionRequest struct {
|
||
ProjectID string `json:"projectId"`
|
||
Prompt string `json:"prompt"`
|
||
CanvasSnapshot map[string]any `json:"canvasSnapshot"`
|
||
References []string `json:"references"`
|
||
Requirements string `json:"requirements"`
|
||
CanvasAssets []storyboardAsset `json:"canvasAssets"`
|
||
ProjectStyle storyboardProjectStyle `json:"projectStyle"`
|
||
Characters []storyboardCharacterCard `json:"characters"`
|
||
Config providerConfig `json:"config"`
|
||
LogicalModelID string `json:"logicalModelId"`
|
||
}
|
||
|
||
type CreateTaskRequest struct {
|
||
SessionID string `json:"sessionId"`
|
||
ProjectID string `json:"projectId"`
|
||
Type string `json:"type"`
|
||
Operation string `json:"operation"`
|
||
Prompt string `json:"prompt"`
|
||
Provider string `json:"provider"`
|
||
Model string `json:"model"`
|
||
LogicalModelID string `json:"logicalModelId"`
|
||
Input map[string]any `json:"input"`
|
||
}
|
||
|
||
type SessionDetail struct {
|
||
Session model.Session `json:"session"`
|
||
Messages []model.Message `json:"messages"`
|
||
Tasks []TaskSummary `json:"tasks"`
|
||
Results []model.Result `json:"results"`
|
||
}
|
||
|
||
type TaskSummary struct {
|
||
ID string `json:"id"`
|
||
SessionID string `json:"sessionId,omitempty"`
|
||
ProjectID string `json:"projectId,omitempty"`
|
||
Type string `json:"type"`
|
||
Status model.TaskStatus `json:"status"`
|
||
Stage string `json:"stage"`
|
||
Progress int `json:"progress"`
|
||
Prompt string `json:"prompt"`
|
||
Operation string `json:"operation,omitempty"`
|
||
Provider string `json:"provider,omitempty"`
|
||
Model string `json:"model,omitempty"`
|
||
ProviderRequestID string `json:"providerRequestId,omitempty"`
|
||
ProviderCancelStatus model.ProviderCancelStatus `json:"providerCancelStatus,omitempty"`
|
||
ProviderCancelError string `json:"providerCancelError,omitempty"`
|
||
ProviderCancelAttempts int `json:"providerCancelAttempts,omitempty"`
|
||
ProviderCancelRequestedAt *time.Time `json:"providerCancelRequestedAt,omitempty"`
|
||
ProviderCancelledAt *time.Time `json:"providerCancelledAt,omitempty"`
|
||
ErrorCode string `json:"errorCode,omitempty"`
|
||
PreviewURL string `json:"previewUrl,omitempty"`
|
||
PreviewKind string `json:"previewKind,omitempty"`
|
||
Attempts int `json:"attempts"`
|
||
StartedAt *time.Time `json:"startedAt"`
|
||
CompletedAt *time.Time `json:"completedAt"`
|
||
CreatedAt time.Time `json:"createdAt"`
|
||
UpdatedAt time.Time `json:"updatedAt"`
|
||
Billing *TaskBillingSummary `json:"billing,omitempty"`
|
||
ClientContext *TaskClientContext `json:"clientContext,omitempty"`
|
||
}
|
||
|
||
type TaskClientContext struct {
|
||
ConversationID string `json:"conversationId"`
|
||
MessageID string `json:"messageId"`
|
||
BatchIndex int `json:"batchIndex,omitempty"`
|
||
BatchCount int `json:"batchCount,omitempty"`
|
||
}
|
||
|
||
type TaskBillingSummary struct {
|
||
AmountMicrocredits int64 `json:"amountMicrocredits"`
|
||
Status model.BillingStatus `json:"status"`
|
||
}
|
||
|
||
type TaskListOptions struct {
|
||
Limit int
|
||
ProjectID string
|
||
ActiveOnly bool
|
||
}
|
||
|
||
type agentStoryboardInput struct {
|
||
References []string `json:"references"`
|
||
CanvasSnapshot map[string]any `json:"canvasSnapshot"`
|
||
Requirements string `json:"requirements"`
|
||
CanvasAssets []storyboardAsset `json:"canvasAssets"`
|
||
ProjectStyle storyboardProjectStyle `json:"projectStyle"`
|
||
Characters []storyboardCharacterCard `json:"characters"`
|
||
Config providerConfig `json:"config"`
|
||
ShotDuration int `json:"shotDurationSeconds"`
|
||
ShotCount int `json:"shotCount"`
|
||
}
|
||
|
||
type storyboardProjectStyle struct {
|
||
PresetID string `json:"presetId"`
|
||
Title string `json:"title"`
|
||
Prompt string `json:"prompt"`
|
||
ProfileJSON string `json:"profileJson,omitempty"`
|
||
}
|
||
|
||
type storyboardCharacterCard struct {
|
||
AssetID string `json:"assetId"`
|
||
VersionID string `json:"versionId"`
|
||
Name string `json:"name"`
|
||
Definition map[string]any `json:"definition"`
|
||
}
|
||
|
||
type storyboardAsset struct {
|
||
ID string `json:"id"`
|
||
Title string `json:"title"`
|
||
Type string `json:"type"`
|
||
Tags []string `json:"tags"`
|
||
Prompt string `json:"prompt"`
|
||
CharacterAssetID string `json:"characterAssetId,omitempty"`
|
||
CharacterVersionID string `json:"characterVersionId,omitempty"`
|
||
}
|
||
|
||
type agentStoryboardPlan struct {
|
||
Title string `json:"title"`
|
||
Logline string `json:"logline"`
|
||
StyleGuide string `json:"styleGuide"`
|
||
Characters []string `json:"characters"`
|
||
Locations []string `json:"locations"`
|
||
Shots []agentStoryboardShot `json:"shots"`
|
||
Raw map[string]interface{} `json:"-"`
|
||
}
|
||
|
||
type agentStoryboardShot struct {
|
||
Title string `json:"title"`
|
||
Description string `json:"description"`
|
||
Duration int `json:"durationSeconds"`
|
||
Dialogue string `json:"dialogue"`
|
||
ShotSize string `json:"shotSize"`
|
||
Emotion string `json:"emotion"`
|
||
Lighting string `json:"lightingAndAtmosphere"`
|
||
AudioEffects string `json:"audioEffects"`
|
||
VisualPrompt string `json:"visualPrompt"`
|
||
VideoPrompt string `json:"videoPrompt"`
|
||
Camera string `json:"camera"`
|
||
Motion string `json:"motion"`
|
||
TimeBeats string `json:"timeBeats"`
|
||
Negative string `json:"negativePrompt"`
|
||
AssetTags []string `json:"assetTags"`
|
||
CharacterIDs []string `json:"characterIds"`
|
||
Intent string `json:"narrativeIntent"`
|
||
ViewerPOV string `json:"viewerPOV"`
|
||
Performance string `json:"performanceBlocking"`
|
||
MustHave []string `json:"mustHave"`
|
||
Optional []string `json:"optionalDetails"`
|
||
ContinuityOut string `json:"continuityOut"`
|
||
}
|
||
|
||
func New(repo *repository.Repository, dataDir string) *Service {
|
||
return NewWithRuntimeCapabilities(repo, dataDir, RuntimeCapabilities{})
|
||
}
|
||
|
||
func NewWithRuntimeCapabilities(repo *repository.Repository, dataDir string, capabilities RuntimeCapabilities) *Service {
|
||
coordinator, err := newRuntimeCoordinator(repo.Dialect())
|
||
return &Service{repo: repo, dataDir: dataDir, runtimeCapabilities: capabilities, activeCancels: make(map[string]context.CancelFunc), coordinator: coordinator, runtimeErr: err, workerID: newID(), routeCatalogTTL: 30 * time.Second, routeCatalogMaxStale: 5 * time.Minute, routeHealthBlocked: make(map[string]time.Time)}
|
||
}
|
||
|
||
func (s *Service) StartWorker() {
|
||
s.startTextReplayCleanup()
|
||
s.startProviderCancellationReconciliation()
|
||
s.startBillingReviewAudit()
|
||
go func() {
|
||
slots := make(chan struct{}, maxChannelConcurrencyLimit)
|
||
dispatch := func() {
|
||
setting, err := s.runtimeConcurrencySetting()
|
||
if err != nil {
|
||
return
|
||
}
|
||
workerConcurrency := setting.WorkerConcurrency
|
||
for len(slots) < workerConcurrency {
|
||
releaseGlobal, acquired, err := s.coordinator.acquire(context.Background(), "workers", workerConcurrency, 45*time.Minute)
|
||
if err != nil || !acquired {
|
||
return
|
||
}
|
||
task, err := s.repo.ClaimNextTask(s.workerID, 45*time.Second)
|
||
if err != nil || task == nil {
|
||
releaseGlobal()
|
||
return
|
||
}
|
||
slots <- struct{}{}
|
||
go func(task *model.Task) {
|
||
defer func() { <-slots; releaseGlobal() }()
|
||
_ = s.processClaimedTask(task)
|
||
}(task)
|
||
}
|
||
}
|
||
|
||
dispatch()
|
||
ticker := time.NewTicker(2 * time.Second)
|
||
defer ticker.Stop()
|
||
for range ticker.C {
|
||
dispatch()
|
||
}
|
||
}()
|
||
}
|
||
|
||
func (s *Service) CreateSession(userID string, req CreateSessionRequest) (*SessionDetail, error) {
|
||
prompt := strings.TrimSpace(req.Prompt)
|
||
if prompt == "" {
|
||
return nil, errors.New("prompt is required")
|
||
}
|
||
if err := validateStoryboardContext(req.ProjectStyle, req.Characters); err != nil {
|
||
return nil, err
|
||
}
|
||
compactedSnapshot := compactPersistedValue(req.CanvasSnapshot)
|
||
snapshotJSON, _ := json.Marshal(compactedSnapshot)
|
||
session := model.Session{ID: newID(), UserID: userID, ProjectID: req.ProjectID, Status: model.SessionStatusActive, Prompt: prompt, CanvasSnapshotJSON: string(snapshotJSON)}
|
||
policy, err := s.RuntimePolicy()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
s.storageMu.Lock()
|
||
usage, err := s.repo.UserStorageUsage(userID)
|
||
if err != nil {
|
||
s.storageMu.Unlock()
|
||
return nil, err
|
||
}
|
||
incomingBytes := int64(len([]byte(prompt))*2 + len(snapshotJSON))
|
||
if err := validateStructuredStorageQuotaWithPolicy(usage, "session", true, incomingBytes, policy.Resource); err != nil {
|
||
s.storageMu.Unlock()
|
||
return nil, err
|
||
}
|
||
if err := s.repo.Create(&session); err != nil {
|
||
s.storageMu.Unlock()
|
||
return nil, err
|
||
}
|
||
if err := s.repo.Create(&model.Message{ID: newID(), UserID: userID, SessionID: session.ID, Role: "user", Content: prompt}); err != nil {
|
||
cleanupErr := s.repo.DeleteSessionDraft(userID, session.ID)
|
||
s.storageMu.Unlock()
|
||
if cleanupErr != nil {
|
||
return nil, fmt.Errorf("创建会话消息失败：%v；清理会话失败：%w", err, cleanupErr)
|
||
}
|
||
return nil, err
|
||
}
|
||
s.storageMu.Unlock()
|
||
taskReq := CreateTaskRequest{SessionID: session.ID, ProjectID: req.ProjectID, Type: "agent_storyboard", Operation: "storyboard", Prompt: prompt, Provider: "openai-compatible", Model: req.Config.Model, LogicalModelID: req.LogicalModelID, Input: map[string]any{"mode": "text", "references": req.References, "canvasSnapshot": compactedSnapshot, "requirements": req.Requirements, "canvasAssets": req.CanvasAssets, "projectStyle": req.ProjectStyle, "characters": req.Characters, "config": req.Config}}
|
||
if _, err := s.CreateTask(userID, taskReq); err != nil {
|
||
s.storageMu.Lock()
|
||
cleanupErr := s.repo.DeleteSessionDraft(userID, session.ID)
|
||
s.storageMu.Unlock()
|
||
if cleanupErr != nil {
|
||
return nil, fmt.Errorf("创建会话任务失败：%v；清理会话失败：%w", err, cleanupErr)
|
||
}
|
||
return nil, err
|
||
}
|
||
s.recordActivity(userID, "agent_message", 1)
|
||
return s.SessionDetail(userID, session.ID)
|
||
}
|
||
|
||
func channelModelNames(channel model.ModelChannel) []string {
|
||
models := []string{}
|
||
_ = json.Unmarshal([]byte(channel.ModelsJSON), &models)
|
||
return uniqueNonEmpty(models)
|
||
}
|
||
|
||
func (s *Service) SessionDetail(userID string, id string) (*SessionDetail, error) {
|
||
session, err := s.repo.SessionForUser(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
messages, err := s.repo.SessionMessages(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
tasks, err := s.repo.SessionTasks(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
taskSummaries := taskSummariesForOutput(tasks)
|
||
results, err := s.repo.SessionResults(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &SessionDetail{Session: *session, Messages: messages, Tasks: taskSummaries, Results: results}, nil
|
||
}
|
||
|
||
func (s *Service) CreateTask(userID string, req CreateTaskRequest) (*model.Task, error) {
|
||
prompt := strings.TrimSpace(req.Prompt)
|
||
if prompt == "" {
|
||
return nil, errors.New("prompt is required")
|
||
}
|
||
normalizedInput, err := normalizeTaskInput(req.Input)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var routed *RoutedModel
|
||
logicalModelID := strings.TrimSpace(req.LogicalModelID)
|
||
if logicalModelID != "" {
|
||
intent := ModelRequestIntentFromTaskInput(normalizedInput, req.Type, req.Operation)
|
||
routed, err = s.ResolveLogicalModel(logicalModelID, intent)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
normalizedInput = applyRoutedProviderSelection(normalizedInput, routed)
|
||
}
|
||
// 前端自管的文本持久化任务：直连模型生成、增量上报 text-deltas，不排入 worker 队列生成。
|
||
if isTextReplayTaskRequest(normalizedInput) {
|
||
return s.createTextReplayTask(userID, req, normalizedInput)
|
||
}
|
||
if err := s.requireCustomChannelsForTaskInput(normalizedInput); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := s.ValidateTaskCapability(normalizedInput); err != nil {
|
||
return nil, err
|
||
}
|
||
if containsInlineMediaDataURL(normalizedInput) {
|
||
return nil, BadAuthRequest("任务输入不能包含内嵌媒体，请先上传到资源存储")
|
||
}
|
||
policy, err := s.RuntimePolicy()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
activeTasks, err := s.repo.ActiveTaskCountForUser(userID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if activeTasks >= int64(policy.Task.ActiveTaskLimit) {
|
||
return nil, BadAuthRequest(fmt.Sprintf("同时排队或运行的任务最多 %d 个，请等待已有任务完成", policy.Task.ActiveTaskLimit))
|
||
}
|
||
taskType := req.Type
|
||
if taskType == "" {
|
||
taskType = "video_image_to_video"
|
||
}
|
||
task := model.Task{ID: newID(), UserID: userID, SessionID: req.SessionID, ProjectID: req.ProjectID, Type: taskType, Status: model.TaskStatusQueued, Stage: "等待队列调度", Progress: 5, Prompt: prompt, Operation: req.Operation, Provider: req.Provider, Model: req.Model}
|
||
if routed != nil {
|
||
task.LogicalModelID = routed.LogicalModel.ID
|
||
task.LogicalModelRevisionID = routed.Revision.ID
|
||
task.RouteID = routed.Route.ID
|
||
task.ChannelModelID = routed.ChannelModel.ID
|
||
task.RouteRun = 1
|
||
task.Model = routed.LogicalModel.Code
|
||
task.Provider = "managed"
|
||
}
|
||
if err := s.ensureTaskProjectActive(userID, req.ProjectID); err != nil {
|
||
return nil, err
|
||
}
|
||
billingOrder, err := s.taskBillingOrder(userID, &task, normalizedInput)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if err := s.protectTaskSecrets(normalizedInput); err != nil {
|
||
return nil, err
|
||
}
|
||
inputJSON, _ := json.Marshal(normalizedInput)
|
||
task.InputJSON = string(inputJSON)
|
||
if billingOrder != nil {
|
||
task.BillingOrderID = billingOrder.ID
|
||
}
|
||
err = s.createTaskWithinStorageQuota(&task, billingOrder, policy)
|
||
if errors.Is(err, repository.ErrActiveTaskLimit) {
|
||
return nil, BadAuthRequest(fmt.Sprintf("同时排队或运行的任务最多 %d 个，请等待已有任务完成", policy.Task.ActiveTaskLimit))
|
||
}
|
||
if errors.Is(err, repository.ErrInsufficientCredits) {
|
||
return nil, BadAuthRequest("积分不足，请先使用兑换码充值")
|
||
}
|
||
if errors.Is(err, repository.ErrLogicalModelUnavailable) {
|
||
return nil, BadAuthRequest("所选模型已停用、归档或配置已更新，请重新选择")
|
||
}
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
s.recordActivity(userID, "task", 1)
|
||
_ = s.log(userID, task.ID, "info", "任务已进入队列", "")
|
||
return taskForOutput(task), nil
|
||
}
|
||
|
||
func applyRoutedProviderSelection(input map[string]any, routed *RoutedModel) map[string]any {
|
||
config, _ := input["config"].(map[string]any)
|
||
nextConfig := make(map[string]any, len(config)+2)
|
||
for key, value := range config {
|
||
switch key {
|
||
case "channelId", "apiFormat", "interfaceType", "baseUrl", "allowLocalChannel", "apiKey", "secretKey", "headers", "model", "capabilityConfig":
|
||
continue
|
||
default:
|
||
nextConfig[key] = value
|
||
}
|
||
}
|
||
for key, value := range routed.Defaults {
|
||
canonical := canonicalCapabilityOptionName(key)
|
||
if existing, exists := nextConfig[canonical]; !exists || existing == nil || strings.TrimSpace(fmt.Sprint(existing)) == "" {
|
||
nextConfig[canonical] = providerConfigOptionValue(value)
|
||
}
|
||
}
|
||
// 路由匹配和真实请求必须使用同一组参数；逻辑能力参数覆盖空的页面配置，但不携带供应链字段。
|
||
if options, ok := input["capabilityOptions"].(map[string]any); ok {
|
||
for key, value := range options {
|
||
canonical := canonicalCapabilityOptionName(key)
|
||
if isProviderCapabilityOption(canonical) {
|
||
nextConfig[canonical] = providerConfigOptionValue(value)
|
||
}
|
||
}
|
||
}
|
||
nextConfig["channelId"] = routed.ChannelModel.ChannelID
|
||
nextConfig["model"] = routed.ChannelModel.ModelKey
|
||
input["config"] = nextConfig
|
||
return input
|
||
}
|
||
|
||
func providerConfigOptionValue(value any) string {
|
||
switch typed := value.(type) {
|
||
case string:
|
||
return typed
|
||
case json.Number:
|
||
return typed.String()
|
||
default:
|
||
return fmt.Sprint(value)
|
||
}
|
||
}
|
||
|
||
// 所有任务输入先收敛为 JSON 对象，确保计费与密钥保护不会因 Go 结构体类型不同而被绕过。
|
||
func normalizeTaskInput(input map[string]any) (map[string]any, error) {
|
||
if input == nil {
|
||
return map[string]any{}, nil
|
||
}
|
||
encoded, err := json.Marshal(input)
|
||
if err != nil {
|
||
return nil, BadAuthRequest("任务输入格式无效")
|
||
}
|
||
var normalized map[string]any
|
||
if err := json.Unmarshal(encoded, &normalized); err != nil {
|
||
return nil, BadAuthRequest("任务输入格式无效")
|
||
}
|
||
if snapshot, ok := normalized["canvasSnapshot"]; ok {
|
||
normalized["canvasSnapshot"] = compactPersistedValue(snapshot)
|
||
}
|
||
return normalized, nil
|
||
}
|
||
|
||
// createTextReplayTask 创建前端自管的文本持久化任务：状态为 text_replay，
|
||
// 不排队执行、不计 active 队列、不产生计费，仅作为正文增量（text-deltas）的存储容器。
|
||
func (s *Service) createTextReplayTask(userID string, req CreateTaskRequest, normalizedInput map[string]any) (*model.Task, error) {
|
||
prompt := strings.TrimSpace(req.Prompt)
|
||
if prompt == "" {
|
||
prompt = strings.TrimSpace(fmt.Sprint(normalizedInput["prompt"]))
|
||
}
|
||
if prompt == "" {
|
||
return nil, errors.New("prompt is required")
|
||
}
|
||
taskType := strings.TrimSpace(req.Type)
|
||
if taskType == "" {
|
||
taskType = "text"
|
||
}
|
||
task := model.Task{
|
||
ID: newID(), UserID: userID, SessionID: req.SessionID, ProjectID: req.ProjectID,
|
||
Type: taskType, Status: model.TaskStatusTextReplay, Stage: "文本持久化（前端自管）", Progress: 5,
|
||
Prompt: prompt, Operation: req.Operation, Provider: req.Provider, Model: strings.TrimSpace(req.Model),
|
||
}
|
||
if err := s.protectTaskSecrets(normalizedInput); err != nil {
|
||
return nil, err
|
||
}
|
||
inputJSON, _ := json.Marshal(normalizedInput)
|
||
task.InputJSON = string(inputJSON)
|
||
policy, err := s.RuntimePolicy()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if err := s.createTaskWithinStorageQuota(&task, nil, policy); err != nil {
|
||
return nil, err
|
||
}
|
||
_ = s.log(userID, task.ID, "info", "文本持久化任务已创建（前端自管）", "")
|
||
return taskForOutput(task), nil
|
||
}
|
||
|
||
func (s *Service) requireCustomChannelsForTaskInput(input map[string]any) error {
|
||
if !taskInputUsesCustomChannel(input) {
|
||
return nil
|
||
}
|
||
return s.RequireFeature(FeatureCustomChannels)
|
||
}
|
||
|
||
func taskInputUsesCustomChannel(input map[string]any) bool {
|
||
config, ok := input["config"].(map[string]any)
|
||
if !ok {
|
||
return false
|
||
}
|
||
channelID, _ := config["channelId"].(string)
|
||
baseURL, _ := config["baseUrl"].(string)
|
||
apiKey, _ := config["apiKey"].(string)
|
||
if strings.TrimSpace(channelID) != "" || systemChannelIDFromBaseURL(baseURL) != "" {
|
||
return false
|
||
}
|
||
return strings.TrimSpace(baseURL) != "" && strings.TrimSpace(apiKey) != ""
|
||
}
|
||
|
||
func compactPersistedValue(value interface{}) interface{} {
|
||
switch item := value.(type) {
|
||
case map[string]interface{}:
|
||
result := make(map[string]interface{}, len(item))
|
||
for key, child := range item {
|
||
if text, ok := child.(string); ok && strings.HasPrefix(text, "data:") {
|
||
result[key] = ""
|
||
continue
|
||
}
|
||
result[key] = compactPersistedValue(child)
|
||
}
|
||
return result
|
||
case []interface{}:
|
||
result := make([]interface{}, len(item))
|
||
for index, child := range item {
|
||
result[index] = compactPersistedValue(child)
|
||
}
|
||
return result
|
||
default:
|
||
return value
|
||
}
|
||
}
|
||
|
||
func (s *Service) Tasks(userID string, limit int) ([]TaskSummary, error) {
|
||
return s.TasksWithOptions(userID, TaskListOptions{Limit: limit})
|
||
}
|
||
|
||
func (s *Service) TasksWithOptions(userID string, options TaskListOptions) ([]TaskSummary, error) {
|
||
tasks, err := s.repo.Tasks(userID, options.Limit, options.ProjectID, options.ActiveOnly)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
orders, err := s.repo.BillingOrdersByTaskIDs(userID, taskBillingTaskIDs(tasks))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return taskSummariesForOutputWithBilling(tasks, orders), nil
|
||
}
|
||
|
||
func (s *Service) Task(userID string, id string) (*model.Task, error) {
|
||
task, err := s.repo.TaskForUser(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
s.hydrateTaskProviderRequestID(task)
|
||
return taskForOutput(*task), nil
|
||
}
|
||
|
||
func (s *Service) hydrateTaskProviderRequestID(task *model.Task) {
|
||
if task == nil || task.ProviderRequestID != "" {
|
||
return
|
||
}
|
||
if task.BillingOrderID != "" {
|
||
if order, err := s.repo.BillingOrder(task.BillingOrderID); err == nil {
|
||
task.ProviderRequestID = strings.TrimSpace(order.ProviderRequestID)
|
||
}
|
||
}
|
||
if task.ProviderRequestID == "" {
|
||
if providerRequestID, err := s.repo.LatestProviderRequestIDForTask(task.ID); err == nil {
|
||
task.ProviderRequestID = providerRequestID
|
||
}
|
||
}
|
||
}
|
||
|
||
// 上游请求日志会在任务执行期间更新 provider 状态，终态保存前必须重新合并，避免旧任务对象覆盖可恢复 ID。
|
||
func (s *Service) refreshTaskProviderState(task *model.Task) error {
|
||
if task == nil || task.ID == "" {
|
||
return errors.New("任务状态无效")
|
||
}
|
||
latest, err := s.repo.Task(task.ID)
|
||
if err != nil {
|
||
return fmt.Errorf("刷新任务上游状态失败：%w", err)
|
||
}
|
||
if latest.ProviderRequestID != "" {
|
||
task.ProviderRequestID = latest.ProviderRequestID
|
||
}
|
||
task.PollStage = latest.PollStage
|
||
task.NextPollAt = latest.NextPollAt
|
||
task.ProviderCancelStatus = latest.ProviderCancelStatus
|
||
task.ProviderCancelError = latest.ProviderCancelError
|
||
task.ProviderCancelAttempts = latest.ProviderCancelAttempts
|
||
task.ProviderCancelRequestedAt = latest.ProviderCancelRequestedAt
|
||
task.ProviderCancelledAt = latest.ProviderCancelledAt
|
||
task.ProviderCancelNextCheckAt = latest.ProviderCancelNextCheckAt
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) RetryTask(userID string, id string) (*model.Task, error) {
|
||
task, err := s.repo.TaskForUser(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if task.Status != model.TaskStatusFailed && task.Status != model.TaskStatusCancelled {
|
||
return nil, errors.New("only failed or cancelled tasks can be retried")
|
||
}
|
||
if task.ProviderCancelStatus == model.ProviderCancelStatusRequested {
|
||
return nil, BadAuthRequest("上游取消状态仍在确认中，请确认费用结果后再重试")
|
||
}
|
||
if task.BillingOrderID != "" {
|
||
if order, orderErr := s.repo.BillingOrder(task.BillingOrderID); orderErr == nil && order.Status == model.BillingStatusUncertain {
|
||
return nil, BadAuthRequest("上一次调用费用仍在核对中，处理完成前不能重复提交")
|
||
}
|
||
}
|
||
if isContentModerationFailure(task.Error) {
|
||
return nil, BadAuthRequest(contentModerationRetryMessage)
|
||
}
|
||
decryptedInput, err := s.decryptTaskInputJSON(task.InputJSON)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var billingInput map[string]any
|
||
if err := json.Unmarshal([]byte(decryptedInput), &billingInput); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := s.prepareLogicalTaskRetry(task, billingInput); err != nil {
|
||
return nil, err
|
||
}
|
||
if err := s.requireCustomChannelsForTaskInput(billingInput); err != nil {
|
||
return nil, err
|
||
}
|
||
billingOrder, err := s.taskBillingOrder(userID, task, billingInput)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
policy, err := s.RuntimePolicy()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if err := s.ensureTaskProjectActive(userID, task.ProjectID); err != nil {
|
||
return nil, err
|
||
}
|
||
task, err = s.repo.RetryTaskWithBilling(userID, task, billingOrder, policy.Task.ActiveTaskLimit)
|
||
if errors.Is(err, repository.ErrInsufficientCredits) {
|
||
return nil, BadAuthRequest("积分不足，请先使用兑换码充值")
|
||
}
|
||
if errors.Is(err, repository.ErrActiveTaskLimit) {
|
||
return nil, BadAuthRequest(fmt.Sprintf("同时排队或运行的任务最多 %d 个，请等待已有任务完成", policy.Task.ActiveTaskLimit))
|
||
}
|
||
if errors.Is(err, repository.ErrTaskNotRetryable) {
|
||
return nil, BadAuthRequest("任务已被其他请求重新入队，请勿重复重试")
|
||
}
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if task.SessionID != "" {
|
||
if session, err := s.repo.SessionForUser(task.UserID, task.SessionID); err == nil {
|
||
session.Status = model.SessionStatusActive
|
||
session.CanvasOpsJSON = ""
|
||
_ = s.repo.Save(session)
|
||
}
|
||
}
|
||
_ = s.log(userID, task.ID, "info", "任务已重新入队", "")
|
||
return taskForOutput(*task), nil
|
||
}
|
||
|
||
func (s *Service) CancelTask(ctx context.Context, userID string, id string) (*model.Task, error) {
|
||
task, err := s.repo.TaskForUser(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if task.Status == model.TaskStatusSucceeded {
|
||
return nil, errors.New("completed task cannot be cancelled")
|
||
}
|
||
now := time.Now()
|
||
cancelledRunningTask := false
|
||
if task.Status == model.TaskStatusQueued {
|
||
cancelled, err := s.repo.CancelTaskIfStatus(userID, task.ID, model.TaskStatusQueued, now)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if cancelled {
|
||
if err := s.RefundBilling(task.BillingOrderID, "任务在调用上游前取消"); err != nil {
|
||
return nil, err
|
||
}
|
||
task, err = s.repo.TaskForUser(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
} else {
|
||
task, err = s.repo.TaskForUser(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
}
|
||
if task.Status == model.TaskStatusRunning {
|
||
cancelled, err := s.repo.CancelTaskIfStatus(userID, task.ID, model.TaskStatusRunning, now)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if !cancelled {
|
||
latest, latestErr := s.repo.TaskForUser(userID, id)
|
||
if latestErr != nil {
|
||
return nil, latestErr
|
||
}
|
||
if latest.Status == model.TaskStatusSucceeded {
|
||
return nil, errors.New("completed task cannot be cancelled")
|
||
}
|
||
task = latest
|
||
} else {
|
||
cancelledRunningTask = true
|
||
s.cancelActiveTask(task.ID)
|
||
if err := s.MarkBillingUncertain(task.BillingOrderID, "运行中的上游请求被用户取消，费用状态待核对"); err != nil {
|
||
return nil, err
|
||
}
|
||
task, err = s.repo.TaskForUser(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
}
|
||
if task.Status != model.TaskStatusCancelled {
|
||
return nil, errors.New("task cannot be cancelled in its current state")
|
||
}
|
||
if task.SessionID != "" {
|
||
_ = s.markSessionFailed(*task, "会话任务已取消。")
|
||
}
|
||
if cancelledRunningTask {
|
||
if err := s.requestProviderCancellation(ctx, task); err != nil {
|
||
return nil, err
|
||
}
|
||
task, err = s.repo.TaskForUser(userID, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
if err := s.finalizeTaskTextReplay(task.ID, model.TaskStatusCancelled); err != nil {
|
||
_ = s.log(userID, task.ID, "error", "文本回放草稿归并失败", err.Error())
|
||
}
|
||
_ = s.log(userID, task.ID, "warn", "任务已取消", "")
|
||
return taskForOutput(*task), nil
|
||
}
|
||
|
||
func (s *Service) TaskLogs(userID string, id string) ([]model.TaskLog, error) {
|
||
return s.repo.TaskLogs(userID, id)
|
||
}
|
||
|
||
func taskSummariesForOutput(tasks []model.Task) []TaskSummary {
|
||
return taskSummariesForOutputWithBilling(tasks, nil)
|
||
}
|
||
|
||
func taskSummariesForOutputWithBilling(tasks []model.Task, orders map[string]model.BillingOrder) []TaskSummary {
|
||
result := make([]TaskSummary, 0, len(tasks))
|
||
for _, task := range tasks {
|
||
summary := taskSummaryForOutput(task)
|
||
if order, ok := orders[task.ID]; ok {
|
||
summary.Billing = &TaskBillingSummary{AmountMicrocredits: order.AmountMicrocredits, Status: order.Status}
|
||
if summary.ProviderRequestID == "" {
|
||
summary.ProviderRequestID = order.ProviderRequestID
|
||
}
|
||
}
|
||
result = append(result, summary)
|
||
}
|
||
return result
|
||
}
|
||
|
||
func taskBillingTaskIDs(tasks []model.Task) []string {
|
||
ids := make([]string, 0, len(tasks))
|
||
seen := map[string]struct{}{}
|
||
for _, task := range tasks {
|
||
if task.BillingOrderID == "" {
|
||
continue
|
||
}
|
||
if _, ok := seen[task.ID]; ok {
|
||
continue
|
||
}
|
||
seen[task.ID] = struct{}{}
|
||
ids = append(ids, task.ID)
|
||
}
|
||
return ids
|
||
}
|
||
|
||
func taskSummaryForOutput(task model.Task) TaskSummary {
|
||
errorCode := ""
|
||
if isContentModerationFailure(task.Error) {
|
||
errorCode = contentModerationErrorCode
|
||
}
|
||
previewURL, previewKind := taskMediaPreview(task.ResultJSON, task.Type)
|
||
return TaskSummary{
|
||
ID: task.ID,
|
||
SessionID: task.SessionID,
|
||
ProjectID: task.ProjectID,
|
||
Type: task.Type,
|
||
Status: task.Status,
|
||
Stage: task.Stage,
|
||
Progress: task.Progress,
|
||
Prompt: truncateRunes(task.Prompt, 500),
|
||
Operation: task.Operation,
|
||
Provider: task.Provider,
|
||
Model: task.Model,
|
||
ProviderRequestID: task.ProviderRequestID,
|
||
ProviderCancelStatus: task.ProviderCancelStatus,
|
||
ProviderCancelError: task.ProviderCancelError,
|
||
ProviderCancelAttempts: task.ProviderCancelAttempts,
|
||
ProviderCancelRequestedAt: task.ProviderCancelRequestedAt,
|
||
ProviderCancelledAt: task.ProviderCancelledAt,
|
||
ErrorCode: errorCode,
|
||
PreviewURL: previewURL,
|
||
PreviewKind: previewKind,
|
||
Attempts: task.Attempts,
|
||
StartedAt: task.StartedAt,
|
||
CompletedAt: task.CompletedAt,
|
||
CreatedAt: task.CreatedAt,
|
||
UpdatedAt: task.UpdatedAt,
|
||
ClientContext: taskClientContext(task.InputJSON),
|
||
}
|
||
}
|
||
|
||
// 列表只暴露创作页恢复所需的关联 ID，不下发完整任务输入或其他 metadata。
|
||
func taskClientContext(raw string) *TaskClientContext {
|
||
var input struct {
|
||
Metadata struct {
|
||
Source string `json:"source"`
|
||
ConversationID string `json:"conversationId"`
|
||
MessageID string `json:"messageId"`
|
||
BatchIndex int `json:"batchIndex"`
|
||
BatchCount int `json:"batchCount"`
|
||
} `json:"metadata"`
|
||
}
|
||
if json.Unmarshal([]byte(raw), &input) != nil || input.Metadata.Source != "create-page" || input.Metadata.ConversationID == "" || input.Metadata.MessageID == "" {
|
||
return nil
|
||
}
|
||
return &TaskClientContext{
|
||
ConversationID: input.Metadata.ConversationID,
|
||
MessageID: input.Metadata.MessageID,
|
||
BatchIndex: input.Metadata.BatchIndex,
|
||
BatchCount: input.Metadata.BatchCount,
|
||
}
|
||
}
|
||
|
||
// 列表只暴露首个可访问媒体地址，避免把完整生成结果和内嵌数据带回前端。
|
||
func taskMediaPreview(raw string, taskType string) (string, string) {
|
||
if strings.TrimSpace(raw) == "" {
|
||
return "", ""
|
||
}
|
||
var payload any
|
||
if json.Unmarshal([]byte(raw), &payload) != nil {
|
||
return "", ""
|
||
}
|
||
defaultKind := "image"
|
||
if strings.Contains(strings.ToLower(taskType), "video") {
|
||
defaultKind = "video"
|
||
}
|
||
return findTaskMediaPreview(payload, defaultKind)
|
||
}
|
||
|
||
func findTaskMediaPreview(value any, hint string) (string, string) {
|
||
switch item := value.(type) {
|
||
case string:
|
||
text := strings.TrimSpace(item)
|
||
if !strings.HasPrefix(text, "/api/resources/") && !strings.HasPrefix(text, "http://") && !strings.HasPrefix(text, "https://") {
|
||
return "", ""
|
||
}
|
||
kind := hint
|
||
lower := strings.ToLower(text)
|
||
if strings.Contains(lower, ".mp4") || strings.Contains(lower, ".webm") || strings.Contains(lower, ".mov") {
|
||
kind = "video"
|
||
} else if kind != "video" {
|
||
kind = "image"
|
||
}
|
||
return text, kind
|
||
case []any:
|
||
for _, child := range item {
|
||
if previewURL, previewKind := findTaskMediaPreview(child, hint); previewURL != "" {
|
||
return previewURL, previewKind
|
||
}
|
||
}
|
||
case map[string]any:
|
||
for _, key := range []string{"images", "image", "video", "dataUrl", "url", "resultUrl", "outputUrl"} {
|
||
child, exists := item[key]
|
||
if !exists {
|
||
continue
|
||
}
|
||
childHint := hint
|
||
if key == "video" {
|
||
childHint = "video"
|
||
} else if key == "images" || key == "image" {
|
||
childHint = "image"
|
||
}
|
||
if previewURL, previewKind := findTaskMediaPreview(child, childHint); previewURL != "" {
|
||
return previewURL, previewKind
|
||
}
|
||
}
|
||
}
|
||
return "", ""
|
||
}
|
||
|
||
func truncateRunes(value string, limit int) string {
|
||
text := []rune(value)
|
||
if len(text) <= limit {
|
||
return value
|
||
}
|
||
return string(text[:limit]) + "..."
|
||
}
|
||
|
||
func taskForOutput(task model.Task) *model.Task {
|
||
task.InputJSON = publicTaskInputJSON(task.InputJSON)
|
||
// 普通任务接口只暴露前台模型身份；渠道模型和供应线路属于管理员内部信息。
|
||
task.LogicalModelRevisionID = ""
|
||
task.RouteID = ""
|
||
task.ChannelModelID = ""
|
||
return &task
|
||
}
|
||
|
||
func publicTaskInputJSON(raw string) string {
|
||
if strings.TrimSpace(raw) == "" {
|
||
return ""
|
||
}
|
||
var input map[string]any
|
||
if err := json.Unmarshal([]byte(raw), &input); err != nil {
|
||
return ""
|
||
}
|
||
public := map[string]any{}
|
||
// 任务完成后仍需依靠这些非敏感 ID 恢复项目产物归属；密钥等配置继续被过滤。
|
||
for _, key := range []string{"mode", "metadata", "workflowStepId", "domainProjectId", "assetVersionId", "resourceId", "mediaType", "role"} {
|
||
if value, ok := input[key]; ok {
|
||
public[key] = value
|
||
}
|
||
}
|
||
if len(public) == 0 {
|
||
return ""
|
||
}
|
||
data, _ := json.Marshal(public)
|
||
return string(data)
|
||
}
|
||
|
||
func (s *Service) StoreUpload(userID string, sessionID string, header *multipart.FileHeader) (*model.SessionFile, error) {
|
||
policy, err := s.RuntimePolicy()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
maxBytes := megabytes(policy.Resource.SessionUploadMB)
|
||
if header == nil || header.Size > maxBytes {
|
||
return nil, BadAuthRequest(fmt.Sprintf("会话文件不能超过 %dMB", policy.Resource.SessionUploadMB))
|
||
}
|
||
day, err := s.reserveSessionUploadQuota(userID, header.Size)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
reserved := true
|
||
defer func() {
|
||
if reserved {
|
||
s.releaseUserUploadQuota(userID, day, header.Size)
|
||
}
|
||
}()
|
||
file, err := header.Open()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
defer file.Close()
|
||
uploadDir := filepath.Join(s.dataDir, "uploads")
|
||
if err := os.MkdirAll(uploadDir, 0o750); err != nil {
|
||
return nil, err
|
||
}
|
||
if strings.TrimSpace(sessionID) != "" {
|
||
if _, err := s.repo.SessionForUser(userID, sessionID); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
storedName := newID() + "-" + filepath.Base(header.Filename)
|
||
path := filepath.Join(uploadDir, storedName)
|
||
dst, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0o640)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
size, err := io.Copy(dst, io.LimitReader(file, maxBytes+1))
|
||
closeErr := dst.Close()
|
||
if err != nil {
|
||
_ = os.Remove(path)
|
||
return nil, err
|
||
}
|
||
if closeErr != nil {
|
||
_ = os.Remove(path)
|
||
return nil, closeErr
|
||
}
|
||
if size > maxBytes {
|
||
_ = os.Remove(path)
|
||
return nil, BadAuthRequest(fmt.Sprintf("会话文件不能超过 %dMB", policy.Resource.SessionUploadMB))
|
||
}
|
||
item := model.SessionFile{ID: newID(), UserID: userID, SessionID: sessionID, FileName: header.Filename, MimeType: header.Header.Get("Content-Type"), Path: path, Size: size}
|
||
if err := s.repo.Create(&item); err != nil {
|
||
_ = os.Remove(path)
|
||
return nil, err
|
||
}
|
||
s.commitUserUploadQuota(userID, header.Size)
|
||
reserved = false
|
||
return &item, nil
|
||
}
|
||
|
||
func (s *Service) ProcessNextTask() error {
|
||
task, err := s.repo.ClaimNextTask(s.workerID, 45*time.Second)
|
||
if err != nil || task == nil {
|
||
return err
|
||
}
|
||
return s.processClaimedTask(task)
|
||
}
|
||
|
||
func (s *Service) processClaimedTask(task *model.Task) error {
|
||
_ = s.log(task.UserID, task.ID, "info", "后端任务开始处理", "")
|
||
policy, err := s.RuntimePolicy()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
ctx, cancel := context.WithTimeout(context.Background(), taskExecutionTimeoutWithPolicy(task.Type, policy.Task))
|
||
defer cancel()
|
||
leaseDone := make(chan struct{})
|
||
leaseLost := make(chan error, 1)
|
||
go func() {
|
||
ticker := time.NewTicker(15 * time.Second)
|
||
defer ticker.Stop()
|
||
for {
|
||
select {
|
||
case <-ticker.C:
|
||
if err := s.repo.RenewTaskLease(task.ID, s.workerID, 45*time.Second); err != nil {
|
||
leaseLost <- err
|
||
cancel()
|
||
return
|
||
}
|
||
case <-leaseDone:
|
||
return
|
||
}
|
||
}
|
||
}()
|
||
defer close(leaseDone)
|
||
s.registerActiveTask(task.ID, cancel)
|
||
defer s.unregisterActiveTask(task.ID)
|
||
|
||
task.Stage = "调用生成模型"
|
||
task.Progress = 35
|
||
_ = s.repo.UpdateTaskProgress(task.ID, task.Stage, task.Progress)
|
||
routeAttempt, err := s.beginTaskRouteAttempt(task)
|
||
if err != nil {
|
||
task.Status = model.TaskStatusFailed
|
||
task.Stage = "路由准备失败"
|
||
task.Error = s.UserFacingErrorMessage(err)
|
||
task.CompletedAt = ptr(time.Now())
|
||
_, _ = s.repo.UpdateTaskTerminalState(task.ID, model.TaskStatusRunning, task.Status, task.Stage, task.Error, *task.CompletedAt)
|
||
if isRouteDispatchUncertain(err) {
|
||
_ = s.MarkBillingUncertain(task.BillingOrderID, task.Error)
|
||
} else {
|
||
_ = s.RefundBilling(task.BillingOrderID, "路由准备失败，上游请求未发出")
|
||
}
|
||
return err
|
||
}
|
||
if err := s.MarkBillingRunning(task.BillingOrderID); err != nil {
|
||
task.Status = model.TaskStatusFailed
|
||
task.Stage = "计费准备失败"
|
||
task.Error = s.UserFacingErrorMessage(err)
|
||
task.CompletedAt = ptr(time.Now())
|
||
_, _ = s.repo.UpdateTaskTerminalState(task.ID, model.TaskStatusRunning, task.Status, task.Stage, task.Error, *task.CompletedAt)
|
||
_ = s.RefundBilling(task.BillingOrderID, "计费准备失败，上游请求未发出")
|
||
return err
|
||
}
|
||
var result map[string]interface{}
|
||
var canvasOps []map[string]interface{}
|
||
for {
|
||
if dispatchErr := s.markRouteAttemptDispatching(routeAttempt); dispatchErr != nil {
|
||
err = dispatchErr
|
||
break
|
||
}
|
||
result, canvasOps, err = s.processTask(ctx, *task)
|
||
if stateErr := s.refreshTaskProviderState(task); stateErr != nil {
|
||
return stateErr
|
||
}
|
||
s.finishTaskRouteAttempt(routeAttempt, task, err)
|
||
if err == nil {
|
||
break
|
||
}
|
||
nextAttempt, routeErr := s.nextRouteAttemptAfterFailure(task, routeAttempt, err)
|
||
if routeErr != nil {
|
||
_ = s.log(task.UserID, task.ID, "warn", "备用路由不可用，保留原始失败", routeErr.Error())
|
||
break
|
||
}
|
||
if nextAttempt == nil {
|
||
break
|
||
}
|
||
routeAttempt = nextAttempt
|
||
_ = s.log(task.UserID, task.ID, "warn", "上游未创建任务，切换备用能力路由", nextAttempt.RouteID)
|
||
}
|
||
providerSucceeded := err == nil
|
||
if err == nil {
|
||
result, err = s.persistGeneratedMediaResult(task.UserID, result)
|
||
}
|
||
if err == nil {
|
||
_, err = s.finalizeCharacterTurnaroundTask(*task, result)
|
||
}
|
||
if err != nil {
|
||
channelSlotFailedBeforeRequest := false
|
||
if code, _ := ChannelSlotFailureDetails(err); code != "" {
|
||
channelSlotFailedBeforeRequest = true
|
||
}
|
||
select {
|
||
case leaseErr := <-leaseLost:
|
||
_ = s.log(task.UserID, task.ID, "warn", "任务租约失效，等待其他 worker 恢复", leaseErr.Error())
|
||
return leaseErr
|
||
default:
|
||
}
|
||
if errors.Is(err, context.Canceled) {
|
||
task.Status = model.TaskStatusCancelled
|
||
task.Stage = "任务已取消"
|
||
task.Error = "任务已取消"
|
||
task.CompletedAt = ptr(time.Now())
|
||
_, _ = s.repo.UpdateTaskTerminalState(task.ID, model.TaskStatusRunning, task.Status, task.Stage, task.Error, *task.CompletedAt)
|
||
if channelSlotFailedBeforeRequest {
|
||
_ = s.RefundBilling(task.BillingOrderID, "等待渠道槽位期间取消，上游请求未发出")
|
||
} else {
|
||
_ = s.MarkBillingUncertain(task.BillingOrderID, "任务取消时上游费用状态不明确")
|
||
}
|
||
_ = s.markSessionFailed(*task, "会话任务已取消。")
|
||
if compactErr := s.finalizeTaskTextReplay(task.ID, model.TaskStatusCancelled); compactErr != nil {
|
||
_ = s.log(task.UserID, task.ID, "error", "文本回放草稿归并失败", compactErr.Error())
|
||
}
|
||
_ = s.log(task.UserID, task.ID, "warn", "任务已取消", "")
|
||
return nil
|
||
}
|
||
if errors.Is(err, context.DeadlineExceeded) {
|
||
decryptedInput, decryptErr := s.decryptTaskInputJSON(task.InputJSON)
|
||
if decryptErr == nil && s.shouldDeferVideoProviderTask(*task, decryptedInput, err) {
|
||
if deferErr := s.repo.DeferRunningTaskForProviderPoll(task.ID, task.LeaseOwner, "后台仍在生成", 15*time.Second); deferErr != nil {
|
||
return deferErr
|
||
}
|
||
_ = s.log(task.UserID, task.ID, "info", "前台等待结束，上游视频仍在生成，将继续回查原任务", task.PollStage)
|
||
return nil
|
||
}
|
||
err = errors.New(taskTimeoutMessage(task.Type))
|
||
}
|
||
task.Status = model.TaskStatusFailed
|
||
task.Stage = "任务失败"
|
||
task.Error = s.UserFacingErrorMessage(err)
|
||
task.CompletedAt = ptr(time.Now())
|
||
_, _ = s.repo.UpdateTaskTerminalState(task.ID, model.TaskStatusRunning, task.Status, task.Stage, task.Error, *task.CompletedAt)
|
||
if compactErr := s.finalizeTaskTextReplay(task.ID, model.TaskStatusFailed); compactErr != nil {
|
||
_ = s.log(task.UserID, task.ID, "error", "文本回放草稿归并失败", compactErr.Error())
|
||
}
|
||
if providerSucceeded || (!channelSlotFailedBeforeRequest && s.BillingFailureRequiresReview(task.BillingOrderID, task.ID, err)) {
|
||
_ = s.MarkBillingUncertain(task.BillingOrderID, task.Error)
|
||
} else {
|
||
_ = s.RefundBilling(task.BillingOrderID, task.Error)
|
||
}
|
||
_ = s.markSessionFailed(*task, task.Error)
|
||
_ = s.log(task.UserID, task.ID, "error", "任务处理失败", task.Error)
|
||
return err
|
||
}
|
||
latest, err := s.repo.Task(task.ID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if latest.Status == model.TaskStatusCancelled {
|
||
if compactErr := s.finalizeTaskTextReplay(task.ID, model.TaskStatusCancelled); compactErr != nil {
|
||
_ = s.log(task.UserID, task.ID, "error", "文本回放草稿归并失败", compactErr.Error())
|
||
}
|
||
_ = s.MarkBillingUncertain(task.BillingOrderID, "上游已返回结果，但任务被取消")
|
||
_ = s.markSessionFailed(*latest, "会话任务已取消。")
|
||
_ = s.log(task.UserID, task.ID, "warn", "任务已取消，丢弃生成结果", "")
|
||
return nil
|
||
}
|
||
resultJSON, _ := json.Marshal(result)
|
||
opsJSON, _ := json.Marshal(canvasOps)
|
||
task.Stage = "持久化生成结果"
|
||
task.Progress = 90
|
||
_ = s.repo.UpdateTaskProgress(task.ID, task.Stage, task.Progress)
|
||
if err := s.saveTaskCompletionWithinStorageQuota(task, resultJSON, opsJSON, len(canvasOps) > 0); err != nil {
|
||
if errors.Is(err, repository.ErrTaskStateConflict) {
|
||
latest, latestErr := s.repo.Task(task.ID)
|
||
if latestErr == nil && latest.Status == model.TaskStatusCancelled {
|
||
_ = s.MarkBillingUncertain(task.BillingOrderID, "上游已返回结果，但任务被取消")
|
||
_ = s.markSessionFailed(*latest, "会话任务已取消。")
|
||
_ = s.log(task.UserID, task.ID, "warn", "任务已取消，丢弃生成结果", "")
|
||
return nil
|
||
}
|
||
}
|
||
task.Status = model.TaskStatusFailed
|
||
task.Stage = "任务结果保存失败"
|
||
task.Error = s.UserFacingErrorMessage(err)
|
||
task.CompletedAt = ptr(time.Now())
|
||
_, _ = s.repo.UpdateTaskTerminalState(task.ID, model.TaskStatusRunning, task.Status, task.Stage, task.Error, *task.CompletedAt)
|
||
if compactErr := s.finalizeTaskTextReplay(task.ID, model.TaskStatusFailed); compactErr != nil {
|
||
_ = s.log(task.UserID, task.ID, "error", "文本回放草稿归并失败", compactErr.Error())
|
||
}
|
||
_ = s.MarkBillingUncertain(task.BillingOrderID, "上游已成功但任务结果未保存："+task.Error)
|
||
_ = s.markSessionFailed(*task, task.Error)
|
||
_ = s.log(task.UserID, task.ID, "error", "任务结果保存失败", task.Error)
|
||
return err
|
||
}
|
||
if compactErr := s.finalizeTaskTextReplay(task.ID, model.TaskStatusSucceeded); compactErr != nil {
|
||
_ = s.log(task.UserID, task.ID, "error", "文本回放窗口更新失败", compactErr.Error())
|
||
}
|
||
if completedTask, fetchErr := s.repo.Task(task.ID); fetchErr == nil {
|
||
if registerErr := s.RegisterTaskOutputFromTask(*completedTask); registerErr != nil {
|
||
// 任务成功与产物登记分开记账；登记失败保持步骤异常，允许项目页幂等补登记。
|
||
_ = s.log(task.UserID, task.ID, "error", "任务成功但项目产物登记失败", registerErr.Error())
|
||
}
|
||
}
|
||
if err := s.SettleBilling(task.BillingOrderID, ""); err != nil {
|
||
_ = s.MarkBillingUncertain(task.BillingOrderID, "生成成功但积分结算失败："+err.Error())
|
||
_ = s.log(task.UserID, task.ID, "error", "积分结算失败，已进入待核对", err.Error())
|
||
}
|
||
_ = s.log(task.UserID, task.ID, "info", "任务完成，结果已持久化", "")
|
||
return nil
|
||
}
|
||
|
||
func taskFailureMessage(err error) string {
|
||
if err == nil {
|
||
return "任务处理失败"
|
||
}
|
||
return truncateRunes(err.Error(), 2_000)
|
||
}
|
||
|
||
func taskExecutionTimeoutWithPolicy(taskType string, policy RuntimeTaskPolicy) time.Duration {
|
||
switch {
|
||
case taskType == "agent_storyboard" || taskType == "agent_storyboard_rows":
|
||
return time.Duration(policy.StoryboardTimeoutMinutes) * time.Minute
|
||
case strings.HasPrefix(taskType, "canvas_video") || strings.HasPrefix(taskType, "video_"):
|
||
return max(time.Duration(policy.VideoTimeoutMinutes)*time.Minute, 5*time.Minute)
|
||
case strings.HasPrefix(taskType, "canvas_image"):
|
||
return time.Duration(policy.ImageTimeoutMinutes) * time.Minute
|
||
case strings.HasPrefix(taskType, "canvas_audio"):
|
||
return time.Duration(policy.AudioTimeoutMinutes) * time.Minute
|
||
case strings.HasPrefix(taskType, "canvas_text"):
|
||
return time.Duration(policy.TextTimeoutMinutes) * time.Minute
|
||
default:
|
||
return time.Duration(policy.DefaultTimeoutMinutes) * time.Minute
|
||
}
|
||
}
|
||
|
||
func (s *Service) shouldDeferVideoProviderTask(task model.Task, decryptedInput string, err error) bool {
|
||
if !errors.Is(err, context.DeadlineExceeded) || strings.TrimSpace(task.ProviderRequestID) == "" || (!strings.HasPrefix(task.Type, "canvas_video") && !strings.HasPrefix(task.Type, "video_")) {
|
||
return false
|
||
}
|
||
var input canvasGenerationInput
|
||
if json.Unmarshal([]byte(decryptedInput), &input) != nil {
|
||
return false
|
||
}
|
||
resolved, resolveErr := s.resolveProviderConfig(input.Config)
|
||
return resolveErr == nil && resolved.InterfaceType == string(model.ChannelInterfaceNewAPIChannel2)
|
||
}
|
||
|
||
func taskTimeoutMessage(taskType string) string {
|
||
if strings.HasPrefix(taskType, "canvas_video") || strings.HasPrefix(taskType, "video_") {
|
||
return "视频生成等待超时，请稍后到任务中心查看或重试。"
|
||
}
|
||
if strings.HasPrefix(taskType, "canvas_image") {
|
||
return "图片生成等待超时，请稍后重试。"
|
||
}
|
||
return "任务执行超时，请稍后重试。"
|
||
}
|
||
|
||
func (s *Service) processTask(ctx context.Context, task model.Task) (map[string]interface{}, []map[string]interface{}, error) {
|
||
decryptedInput, err := s.decryptTaskInputJSON(task.InputJSON)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
task.InputJSON = decryptedInput
|
||
ctx = withProviderAnalytics(ctx, s, task)
|
||
if task.Type == "agent_storyboard_rows" {
|
||
return s.processStoryboardRowsTask(ctx, task)
|
||
}
|
||
if strings.HasPrefix(task.Type, "canvas_") || canRunProviderTask(task) {
|
||
result, err := s.processCanvasGenerationTask(ctx, task.UserID, task.ProjectID, task.Type, task.Prompt, task.InputJSON)
|
||
return result, nil, err
|
||
}
|
||
if task.Type == "agent_storyboard" {
|
||
return s.processAgentStoryboardTask(ctx, task)
|
||
}
|
||
if strings.HasPrefix(task.Type, "video_") {
|
||
result, ops := buildVideoWorkflowResult(task)
|
||
return result, ops, nil
|
||
}
|
||
result, ops := buildAgentResult(task)
|
||
return result, ops, nil
|
||
}
|
||
|
||
func canRunProviderTask(task model.Task) bool {
|
||
if !strings.HasPrefix(task.Type, "video_") || strings.TrimSpace(task.InputJSON) == "" {
|
||
return false
|
||
}
|
||
var input map[string]any
|
||
if err := json.Unmarshal([]byte(task.InputJSON), &input); err != nil {
|
||
return false
|
||
}
|
||
mode, _ := input["mode"].(string)
|
||
config, ok := input["config"].(map[string]any)
|
||
if mode != "video" || !ok || strings.TrimSpace(fmt.Sprint(config["model"])) == "" {
|
||
return false
|
||
}
|
||
return strings.TrimSpace(fmt.Sprint(config["channelId"])) != "" || (strings.TrimSpace(fmt.Sprint(config["baseUrl"])) != "" && strings.TrimSpace(fmt.Sprint(config["apiKey"])) != "")
|
||
}
|
||
|
||
func (s *Service) processAgentStoryboardTask(ctx context.Context, task model.Task) (map[string]interface{}, []map[string]interface{}, error) {
|
||
input := agentStoryboardInput{}
|
||
if strings.TrimSpace(task.InputJSON) != "" {
|
||
if err := json.Unmarshal([]byte(task.InputJSON), &input); err != nil {
|
||
return nil, nil, fmt.Errorf("Agent 会话输入解析失败：%w", err)
|
||
}
|
||
}
|
||
if !providerConfigReady(input.Config) {
|
||
return nil, nil, errors.New("请先配置可用的文本模型")
|
||
}
|
||
if err := validateStoryboardContext(input.ProjectStyle, input.Characters); err != nil {
|
||
return nil, nil, err
|
||
}
|
||
assets := input.CanvasAssets
|
||
if len(assets) == 0 {
|
||
assets = extractStoryboardAssets(input.CanvasSnapshot)
|
||
}
|
||
config, err := s.resolveProviderConfig(input.Config)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
ctx = withProviderOutboundPolicy(ctx, config)
|
||
plannerPrompt, err := s.buildAgentStoryboardPlannerPrompt(task.UserID, task.Prompt, input.Requirements, assets, input.ProjectStyle, input.Characters, 0, 0)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
result, err := runTextTask(ctx, canvasGenerationInput{Mode: "text", Prompt: plannerPrompt, Config: config, StreamText: true})
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
text, _ := result["text"].(string)
|
||
plan, err := parseAgentStoryboardPlan(text)
|
||
if err == nil {
|
||
normalizeAutomaticStoryboardDurations(&plan, 0)
|
||
err = validateStoryboardPlan(plan, 0, 0, input.Characters)
|
||
}
|
||
if err != nil {
|
||
plan, err = s.repairStoryboardPlan(ctx, task, input, config, text, err, 0, 0)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
}
|
||
if complexityErr := validateStoryboardComplexity(plan); complexityErr != nil {
|
||
_ = s.log(task.UserID, task.ID, "warn", "分镜复杂度建议", complexityErr.Error())
|
||
}
|
||
return s.buildAgentStoryboardResult(task, plan, assets, input.ProjectStyle)
|
||
}
|
||
|
||
func (s *Service) processStoryboardRowsTask(ctx context.Context, task model.Task) (map[string]interface{}, []map[string]interface{}, error) {
|
||
input := agentStoryboardInput{}
|
||
if strings.TrimSpace(task.InputJSON) != "" {
|
||
if err := json.Unmarshal([]byte(task.InputJSON), &input); err != nil {
|
||
return nil, nil, fmt.Errorf("脚本任务输入解析失败：%w", err)
|
||
}
|
||
}
|
||
if !providerConfigReady(input.Config) {
|
||
return nil, nil, errors.New("请先配置可用的文本模型")
|
||
}
|
||
if err := validateStoryboardContext(input.ProjectStyle, input.Characters); err != nil {
|
||
return nil, nil, err
|
||
}
|
||
assets := input.CanvasAssets
|
||
if len(assets) == 0 {
|
||
assets = extractStoryboardAssets(input.CanvasSnapshot)
|
||
}
|
||
config, err := s.resolveProviderConfig(input.Config)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
ctx = withProviderOutboundPolicy(ctx, config)
|
||
plannerPrompt, err := s.buildAgentStoryboardPlannerPrompt(task.UserID, task.Prompt, input.Requirements, assets, input.ProjectStyle, input.Characters, input.ShotDuration, input.ShotCount)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
result, err := runTextTask(ctx, canvasGenerationInput{Mode: "text", Prompt: plannerPrompt, Config: config, StreamText: true})
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
text, _ := result["text"].(string)
|
||
plan, err := parseAgentStoryboardPlan(text)
|
||
if err == nil {
|
||
normalizeAutomaticStoryboardDurations(&plan, input.ShotDuration)
|
||
err = validateStoryboardPlan(plan, input.ShotDuration, input.ShotCount, input.Characters)
|
||
}
|
||
if err != nil {
|
||
plan, err = s.repairStoryboardPlan(ctx, task, input, config, text, err, input.ShotDuration, input.ShotCount)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
}
|
||
if complexityErr := validateStoryboardComplexity(plan); complexityErr != nil {
|
||
_ = s.log(task.UserID, task.ID, "warn", "分镜复杂度建议", complexityErr.Error())
|
||
}
|
||
rows := make([]map[string]any, 0, len(plan.Shots))
|
||
for index, shot := range plan.Shots {
|
||
imagePromptVariables := storyboardImagePromptValues(input.ProjectStyle.Prompt, plan.StyleGuide, shot)
|
||
videoPromptVariables := storyboardVideoPromptValues(input.ProjectStyle.Prompt, plan.StyleGuide, shot)
|
||
imagePrompt, promptErr := s.compileStoryboardImagePrompt(task.UserID, input.ProjectStyle.Prompt, plan.StyleGuide, shot)
|
||
if promptErr != nil {
|
||
return nil, nil, promptErr
|
||
}
|
||
videoPrompt, promptErr := s.compileStoryboardVideoPrompt(task.UserID, input.ProjectStyle.Prompt, plan.StyleGuide, shot)
|
||
if promptErr != nil {
|
||
return nil, nil, promptErr
|
||
}
|
||
matchedAssets := matchStoryboardAssets(assets, shot.AssetTags)
|
||
referenceNodeIDs := make([]string, 0, len(matchedAssets))
|
||
for _, asset := range matchedAssets {
|
||
referenceNodeIDs = append(referenceNodeIDs, asset.ID)
|
||
}
|
||
rows = append(rows, map[string]any{
|
||
"shotNumber": index + 1, "durationSeconds": shot.Duration, "plotDescription": shot.Description,
|
||
"dialogue": shot.Dialogue, "characters": storyboardRowCharacters(shot, input.Characters), "shotSize": shot.ShotSize, "emotion": shot.Emotion,
|
||
"lightingAndAtmosphere": shot.Lighting, "audioEffects": shot.AudioEffects,
|
||
"imageGenerationPrompt": imagePrompt, "videoMotionPrompt": videoPrompt,
|
||
"imagePromptTemplateVariables": imagePromptVariables, "videoPromptTemplateVariables": videoPromptVariables,
|
||
"camera": shot.Camera, "motion": shot.Motion, "timeBeats": shot.TimeBeats, "negativePrompt": shot.Negative,
|
||
"narrativeIntent": shot.Intent, "viewerPOV": shot.ViewerPOV, "performanceBlocking": shot.Performance,
|
||
"mustHave": shot.MustHave, "optionalDetails": shot.Optional, "continuityOut": shot.ContinuityOut,
|
||
"referenceNodeIds": referenceNodeIDs, "assetTags": shot.AssetTags,
|
||
})
|
||
}
|
||
return map[string]interface{}{"title": plan.Title, "rows": rows}, nil, nil
|
||
}
|
||
|
||
const maxStoryboardRepairAttempts = 2
|
||
|
||
func (s *Service) repairStoryboardPlan(ctx context.Context, task model.Task, input agentStoryboardInput, config providerConfig, originalText string, validationErr error, shotDuration int, shotCount int) (agentStoryboardPlan, error) {
|
||
currentText := originalText
|
||
currentErr := validationErr
|
||
for attempt := 1; attempt <= maxStoryboardRepairAttempts; attempt++ {
|
||
_ = s.repo.UpdateTaskProgress(task.ID, "修复分镜结构", 55+attempt*10)
|
||
repairPrompt, promptErr := s.buildStoryboardRepairPrompt(task.UserID, task.Prompt, currentErr, input, currentText)
|
||
if promptErr != nil {
|
||
return agentStoryboardPlan{}, promptErr
|
||
}
|
||
repaired, repairErr := runTextTask(withProviderRequestKind(ctx, "repair"), canvasGenerationInput{Mode: "text", Prompt: repairPrompt, Config: config, StreamText: true})
|
||
if repairErr != nil {
|
||
return agentStoryboardPlan{}, fmt.Errorf("分镜结构修复失败：%w", repairErr)
|
||
}
|
||
repairedText, _ := repaired["text"].(string)
|
||
plan, parseErr := parseAgentStoryboardPlan(repairedText)
|
||
if parseErr == nil {
|
||
normalizeAutomaticStoryboardDurations(&plan, shotDuration)
|
||
parseErr = validateStoryboardPlan(plan, shotDuration, shotCount, input.Characters)
|
||
}
|
||
if parseErr == nil {
|
||
return plan, nil
|
||
}
|
||
currentText = repairedText
|
||
currentErr = parseErr
|
||
}
|
||
return agentStoryboardPlan{}, fmt.Errorf("分镜模型结构修复后仍不合法：%w", currentErr)
|
||
}
|
||
|
||
func providerConfigReady(config providerConfig) bool {
|
||
return strings.TrimSpace(config.Model) != "" && (strings.TrimSpace(config.ChannelID) != "" || (strings.TrimSpace(config.BaseURL) != "" && strings.TrimSpace(config.APIKey) != ""))
|
||
}
|
||
|
||
func parseAgentStoryboardPlan(raw string) (agentStoryboardPlan, error) {
|
||
jsonText, err := extractJSONText(raw)
|
||
if err != nil {
|
||
return agentStoryboardPlan{}, err
|
||
}
|
||
if err := validateStoryboardJSONFields(jsonText); err != nil {
|
||
return agentStoryboardPlan{}, err
|
||
}
|
||
var plan agentStoryboardPlan
|
||
if err := json.Unmarshal([]byte(jsonText), &plan); err != nil {
|
||
return agentStoryboardPlan{}, fmt.Errorf("分镜 JSON 解析失败：%w", err)
|
||
}
|
||
plan.Title = defaultString(strings.TrimSpace(plan.Title), "影视分镜")
|
||
plan.Logline = defaultString(strings.TrimSpace(plan.Logline), "根据剧情生成的分镜方案")
|
||
plan.StyleGuide = defaultString(strings.TrimSpace(plan.StyleGuide), "严格沿用当前项目画风，保持角色、空间、道具、色彩和视觉媒介一致。")
|
||
if len(plan.Shots) == 0 {
|
||
return agentStoryboardPlan{}, errors.New("分镜模型没有返回 shots")
|
||
}
|
||
if len(plan.Shots) > 12 {
|
||
return agentStoryboardPlan{}, fmt.Errorf("分镜数量最多 12 个，实际返回 %d 个", len(plan.Shots))
|
||
}
|
||
for i := range plan.Shots {
|
||
if strings.TrimSpace(plan.Shots[i].Title) == "" {
|
||
plan.Shots[i].Title = fmt.Sprintf("镜头 %d", i+1)
|
||
}
|
||
plan.Shots[i].CharacterIDs = nonNilStrings(plan.Shots[i].CharacterIDs)
|
||
plan.Shots[i].AssetTags = nonNilStrings(plan.Shots[i].AssetTags)
|
||
plan.Shots[i].Optional = nonNilStrings(plan.Shots[i].Optional)
|
||
plan.Shots[i].Intent = defaultString(strings.TrimSpace(plan.Shots[i].Intent), strings.TrimSpace(plan.Shots[i].Description))
|
||
plan.Shots[i].ViewerPOV = defaultString(strings.TrimSpace(plan.Shots[i].ViewerPOV), "客观观察当前主要角色与事件")
|
||
plan.Shots[i].Performance = defaultString(strings.TrimSpace(plan.Shots[i].Performance), strings.TrimSpace(plan.Shots[i].Description))
|
||
plan.Shots[i].ContinuityOut = defaultString(strings.TrimSpace(plan.Shots[i].ContinuityOut), "保持本镜头结尾的人物位置、动作状态、道具和光线方向进入下一镜")
|
||
if len(plan.Shots[i].MustHave) == 0 {
|
||
plan.Shots[i].MustHave = []string{"主要角色身份与当前版本稳定", "主要动作完成并有清晰落点", "结尾状态可供下一镜继承"}
|
||
}
|
||
if strings.TrimSpace(plan.Shots[i].VideoPrompt) == "" {
|
||
plan.Shots[i].VideoPrompt = defaultString(plan.Shots[i].VisualPrompt, plan.Shots[i].Description)
|
||
}
|
||
if strings.TrimSpace(plan.Shots[i].VisualPrompt) == "" {
|
||
return agentStoryboardPlan{}, fmt.Errorf("镜头 %d 缺少 visualPrompt", i+1)
|
||
}
|
||
if strings.TrimSpace(plan.Shots[i].Camera) == "" || strings.TrimSpace(plan.Shots[i].Motion) == "" || strings.TrimSpace(plan.Shots[i].TimeBeats) == "" {
|
||
return agentStoryboardPlan{}, fmt.Errorf("镜头 %d 缺少 camera、motion 或 timeBeats", i+1)
|
||
}
|
||
if plan.Shots[i].Duration <= 0 || plan.Shots[i].Duration > 60 {
|
||
return agentStoryboardPlan{}, fmt.Errorf("镜头 %d 的 durationSeconds 必须在 1 到 60 之间", i+1)
|
||
}
|
||
}
|
||
return plan, nil
|
||
}
|
||
|
||
func validateStoryboardJSONFields(jsonText string) error {
|
||
var root map[string]json.RawMessage
|
||
if err := json.Unmarshal([]byte(jsonText), &root); err != nil {
|
||
return fmt.Errorf("分镜 JSON 解析失败：%w", err)
|
||
}
|
||
for _, field := range []string{"title", "logline", "styleGuide", "characters", "locations", "shots"} {
|
||
if _, ok := root[field]; !ok {
|
||
return fmt.Errorf("分镜 JSON 缺少受保护字段 %s", field)
|
||
}
|
||
}
|
||
var shots []map[string]json.RawMessage
|
||
if err := json.Unmarshal(root["shots"], &shots); err != nil {
|
||
return errors.New("分镜 JSON 的 shots 必须是数组")
|
||
}
|
||
required := []string{"title", "description", "durationSeconds", "dialogue", "characterIds", "narrativeIntent", "viewerPOV", "performanceBlocking", "shotSize", "emotion", "lightingAndAtmosphere", "audioEffects", "visualPrompt", "videoPrompt", "camera", "motion", "timeBeats", "mustHave", "optionalDetails", "continuityOut", "negativePrompt", "assetTags"}
|
||
for index, shot := range shots {
|
||
for _, field := range required {
|
||
if _, ok := shot[field]; !ok {
|
||
return fmt.Errorf("镜头 %d 缺少受保护字段 %s", index+1, field)
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func nonNilStrings(values []string) []string {
|
||
if values == nil {
|
||
return []string{}
|
||
}
|
||
return values
|
||
}
|
||
|
||
func validateStoryboardContext(projectStyle storyboardProjectStyle, characters []storyboardCharacterCard) error {
|
||
if strings.TrimSpace(projectStyle.PresetID) == "" || strings.TrimSpace(projectStyle.Title) == "" || strings.TrimSpace(projectStyle.Prompt) == "" {
|
||
return errors.New("请先设置项目画风，再生成分镜")
|
||
}
|
||
if strings.TrimSpace(projectStyle.ProfileJSON) != "" {
|
||
if _, err := validateStyleProfileJSON(projectStyle.ProfileJSON); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
for _, character := range characters {
|
||
if strings.TrimSpace(character.AssetID) == "" || strings.TrimSpace(character.VersionID) == "" || strings.TrimSpace(character.Name) == "" {
|
||
return errors.New("角色卡缺少当前资产版本，请刷新角色资产后再生成分镜")
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateStoryboardShotDuration(plan agentStoryboardPlan, target int) error {
|
||
if target == 0 {
|
||
return nil
|
||
}
|
||
if target != 5 && target != 10 && target != 15 && target != 30 {
|
||
return fmt.Errorf("不支持的单镜头时长：%d 秒", target)
|
||
}
|
||
for index, shot := range plan.Shots {
|
||
if shot.Duration != target {
|
||
return fmt.Errorf("镜头 %d 的时长必须是 %d 秒", index+1, target)
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateStoryboardPlan(plan agentStoryboardPlan, shotDuration int, shotCount int, characters []storyboardCharacterCard) error {
|
||
if utf8.RuneCountInString(strings.TrimSpace(plan.StyleGuide)) > 120 {
|
||
return errors.New("styleGuide 最多 120 个中文字符")
|
||
}
|
||
if err := validateStoryboardShotDuration(plan, shotDuration); err != nil {
|
||
return err
|
||
}
|
||
if err := validateStoryboardShotCount(plan, shotCount); err != nil {
|
||
return err
|
||
}
|
||
if err := validateStoryboardCharacterIDs(plan, characters); err != nil {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateStoryboardShotCount(plan agentStoryboardPlan, target int) error {
|
||
if target == 0 {
|
||
return nil
|
||
}
|
||
if target < 1 || target > 10 {
|
||
return fmt.Errorf("分镜数量必须在 1 到 10 之间")
|
||
}
|
||
if len(plan.Shots) != target {
|
||
return fmt.Errorf("分镜数量必须是 %d，实际生成 %d", target, len(plan.Shots))
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func validateStoryboardComplexity(plan agentStoryboardPlan) error {
|
||
issues := make([]string, 0)
|
||
for index, shot := range plan.Shots {
|
||
shotNumber := index + 1
|
||
if len(shot.CharacterIDs) > 2 {
|
||
issues = append(issues, fmt.Sprintf("镜头 %d 有 %d 名主要角色，最多 2 名", shotNumber, len(shot.CharacterIDs)))
|
||
}
|
||
if len(shot.MustHave) > 3 {
|
||
issues = append(issues, fmt.Sprintf("镜头 %d 有 %d 个必须完成项，最多 3 个", shotNumber, len(shot.MustHave)))
|
||
}
|
||
if beats := storyboardBeatCount(shot.TimeBeats); beats > 3 {
|
||
issues = append(issues, fmt.Sprintf("镜头 %d 有 %d 个时间节拍，最多 3 个", shotNumber, beats))
|
||
}
|
||
if movements := storyboardCameraMovementCount(shot.Motion); movements > 1 {
|
||
issues = append(issues, fmt.Sprintf("镜头 %d 包含 %d 种主运镜，最多 1 种", shotNumber, movements))
|
||
}
|
||
dialogueLimit := max(24, shot.Duration*5)
|
||
if dialogueLength := utf8.RuneCountInString(strings.TrimSpace(shot.Dialogue)); dialogueLength > dialogueLimit {
|
||
issues = append(issues, fmt.Sprintf("镜头 %d 台词 %d 字，%d 秒镜头最多约 %d 字", shotNumber, dialogueLength, shot.Duration, dialogueLimit))
|
||
}
|
||
}
|
||
if len(issues) == 0 {
|
||
return nil
|
||
}
|
||
return fmt.Errorf("镜头复杂度超限：%s", strings.Join(issues, "；"))
|
||
}
|
||
|
||
func normalizeAutomaticStoryboardDurations(plan *agentStoryboardPlan, target int) {
|
||
if plan == nil || target != 0 {
|
||
return
|
||
}
|
||
for index := range plan.Shots {
|
||
shot := &plan.Shots[index]
|
||
dialogueLength := utf8.RuneCountInString(strings.TrimSpace(shot.Dialogue))
|
||
requiredDuration := (dialogueLength + 4) / 5
|
||
shot.Duration = min(60, max(1, shot.Duration, requiredDuration))
|
||
}
|
||
}
|
||
|
||
func validateStoryboardCharacterIDs(plan agentStoryboardPlan, characters []storyboardCharacterCard) error {
|
||
allowed := make(map[string]bool, len(characters))
|
||
for _, character := range characters {
|
||
allowed[character.AssetID] = true
|
||
}
|
||
for index, shot := range plan.Shots {
|
||
for _, assetID := range shot.CharacterIDs {
|
||
if !allowed[assetID] {
|
||
return fmt.Errorf("镜头 %d 引用了不存在或非当前版本的角色 assetId：%s", index+1, assetID)
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func storyboardRowCharacters(shot agentStoryboardShot, characters []storyboardCharacterCard) []map[string]any {
|
||
byID := make(map[string]storyboardCharacterCard, len(characters))
|
||
for _, character := range characters {
|
||
byID[character.AssetID] = character
|
||
}
|
||
result := make([]map[string]any, 0, len(shot.CharacterIDs))
|
||
for _, assetID := range shot.CharacterIDs {
|
||
character, ok := byID[assetID]
|
||
if !ok {
|
||
continue
|
||
}
|
||
result = append(result, map[string]any{
|
||
"characterName": character.Name,
|
||
"characterAssetId": character.AssetID,
|
||
"characterVersionId": character.VersionID,
|
||
})
|
||
}
|
||
return result
|
||
}
|
||
|
||
func storyboardBeatCount(value string) int {
|
||
parts := strings.FieldsFunc(value, func(r rune) bool { return r == '；' || r == ';' || r == '\n' })
|
||
count := 0
|
||
for _, part := range parts {
|
||
if strings.TrimSpace(part) != "" {
|
||
count++
|
||
}
|
||
}
|
||
timecodeCount := len(storyboardTimecodePattern.FindAllString(value, -1))
|
||
return max(count, timecodeCount)
|
||
}
|
||
|
||
var storyboardTimecodePattern = regexp.MustCompile(`\d+(?:\.\d+)?\s*[-~—至到]\s*\d+(?:\.\d+)?\s*秒`)
|
||
|
||
func storyboardCameraMovementCount(value string) int {
|
||
movements := []string{"推进", "推近", "拉远", "摇摄", "横移", "侧移", "跟拍", "跟随", "升降", "上升", "下降", "环绕", "俯冲", "变焦", "甩镜", "穿越"}
|
||
count := 0
|
||
for _, movement := range movements {
|
||
if strings.Contains(value, movement) {
|
||
count++
|
||
}
|
||
}
|
||
return count
|
||
}
|
||
|
||
func extractJSONText(raw string) (string, error) {
|
||
// Text models may prepend an explanation or append a Markdown fence despite
|
||
// the JSON-only contract. Scan complete JSON values instead of pairing the
|
||
// first opening brace with the final closing brace, which can merge prose and
|
||
// make an otherwise valid character breakdown fail validation.
|
||
for start := 0; start < len(raw); start++ {
|
||
if raw[start] != '{' && raw[start] != '[' {
|
||
continue
|
||
}
|
||
end := jsonValueEnd(raw, start)
|
||
if end < start {
|
||
continue
|
||
}
|
||
candidate := raw[start : end+1]
|
||
var decoded interface{}
|
||
if json.Unmarshal([]byte(candidate), &decoded) == nil {
|
||
return candidate, nil
|
||
}
|
||
}
|
||
return "", errors.New("模型返回的不是 JSON")
|
||
}
|
||
|
||
func jsonValueEnd(source string, start int) int {
|
||
stack := make([]byte, 0, 8)
|
||
inString := false
|
||
escaped := false
|
||
for index := start; index < len(source); index++ {
|
||
value := source[index]
|
||
if inString {
|
||
if escaped {
|
||
escaped = false
|
||
} else if value == '\\' {
|
||
escaped = true
|
||
} else if value == '"' {
|
||
inString = false
|
||
}
|
||
continue
|
||
}
|
||
switch value {
|
||
case '"':
|
||
inString = true
|
||
case '{', '[':
|
||
stack = append(stack, value)
|
||
case '}', ']':
|
||
if len(stack) == 0 {
|
||
return -1
|
||
}
|
||
opener := stack[len(stack)-1]
|
||
if (value == '}' && opener != '{') || (value == ']' && opener != '[') {
|
||
return -1
|
||
}
|
||
stack = stack[:len(stack)-1]
|
||
if len(stack) == 0 {
|
||
return index
|
||
}
|
||
}
|
||
}
|
||
return -1
|
||
}
|
||
|
||
func (s *Service) buildAgentStoryboardResult(task model.Task, plan agentStoryboardPlan, assets []storyboardAsset, projectStyle storyboardProjectStyle) (map[string]interface{}, []map[string]interface{}, error) {
|
||
prefix := "agent-" + task.ID
|
||
scriptID := prefix + "-script"
|
||
sceneID := prefix + "-scenes"
|
||
styleID := prefix + "-style"
|
||
referenceID := prefix + "-assets"
|
||
finalID := prefix + "-final"
|
||
sceneX := 380
|
||
styleX := sceneX + 380
|
||
ops := []map[string]any{
|
||
nodeOpWithMetadata(scriptID, "text", "剧本 · "+shortTitle(plan.Title, 24), 0, 0, map[string]any{"workflowKind": "script", "workflowTitle": "剧本", "status": "success", "content": strings.Join([]string{plan.Title, "", plan.Logline, "", task.Prompt}, "\n")}),
|
||
nodeOpWithMetadata(sceneID, "text", "场景设定", sceneX, 0, map[string]any{"workflowKind": "scene", "workflowTitle": "场景", "status": "success", "content": listContent("场景", plan.Locations)}),
|
||
nodeOpWithMetadata(styleID, "text", "项目画风 · "+shortTitle(projectStyle.Title, 24), styleX, 0, map[string]any{"workflowKind": "styleboard", "workflowTitle": "项目画风", "workflowDescription": plan.StyleGuide, "stylePresetId": projectStyle.PresetID, "styleProfileJson": projectStyle.ProfileJSON, "status": "success", "content": projectStyle.Prompt, "prompt": projectStyle.Prompt}),
|
||
nodeOpWithMetadata(referenceID, "text", "参考素材组", 0, 270, map[string]any{"workflowKind": "reference_set", "workflowTitle": "参考素材组", "status": "success", "content": storyboardAssetsContent(assets)}),
|
||
nodeOpWithMetadata(finalID, "video", "成片 · 待生成", styleX, 270, map[string]any{"workflowKind": "final", "workflowTitle": "成片", "status": "idle"}),
|
||
connectOp(scriptID, sceneID),
|
||
}
|
||
resultShots := make([]map[string]any, 0, len(plan.Shots))
|
||
for index, shot := range plan.Shots {
|
||
videoPrompt, err := s.compileStoryboardVideoPrompt(task.UserID, projectStyle.Prompt, plan.StyleGuide, shot)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
shotID := fmt.Sprintf("%s-shot-%d", prefix, index+1)
|
||
matchedAssets := matchStoryboardAssetsForShot(assets, shot)
|
||
assetIDs := make([]string, 0, len(matchedAssets))
|
||
for _, asset := range matchedAssets {
|
||
assetIDs = append(assetIDs, asset.ID)
|
||
}
|
||
ops = append(ops,
|
||
nodeOpWithMetadata(shotID, "video", fmt.Sprintf("镜头 %d · %s", index+1, shortTitle(shot.Title, 18)), index*360, 560, map[string]any{
|
||
"workflowKind": "shot",
|
||
"workflowTitle": shot.Title,
|
||
"workflowDescription": shotDescription(shot),
|
||
"shotIndex": index + 1,
|
||
"generationMode": "video",
|
||
"prompt": videoPrompt,
|
||
"composerContent": shotComposerContent(videoPrompt, matchedAssets),
|
||
"videoEditOperation": "text_to_video",
|
||
"assetTags": shot.AssetTags,
|
||
"referenceAssetNodeIds": assetIDs,
|
||
"status": "idle",
|
||
}),
|
||
connectOp(scriptID, shotID),
|
||
connectOp(shotID, finalID),
|
||
)
|
||
for _, asset := range matchedAssets {
|
||
ops = append(ops, connectOp(asset.ID, shotID))
|
||
}
|
||
resultShots = append(resultShots, map[string]any{"title": shot.Title, "description": shot.Description, "assetTags": shot.AssetTags, "referenceAssetNodeIds": assetIDs})
|
||
}
|
||
ops = append(ops, map[string]any{"type": "select_nodes", "ids": shotIDs(prefix, len(plan.Shots))})
|
||
result := map[string]any{
|
||
"taskId": task.ID,
|
||
"operation": task.Operation,
|
||
"provider": defaultString(task.Provider, "internal-agent"),
|
||
"model": defaultString(task.Model, "workflow-router"),
|
||
"title": plan.Title,
|
||
"logline": plan.Logline,
|
||
"styleGuide": plan.StyleGuide,
|
||
"characters": plan.Characters,
|
||
"locations": plan.Locations,
|
||
"shots": resultShots,
|
||
}
|
||
return result, ops, nil
|
||
}
|
||
|
||
func extractStoryboardAssets(snapshot map[string]any) []storyboardAsset {
|
||
rawNodes, _ := snapshot["nodes"].([]interface{})
|
||
assets := make([]storyboardAsset, 0, len(rawNodes))
|
||
for _, raw := range rawNodes {
|
||
node, _ := raw.(map[string]interface{})
|
||
if node == nil {
|
||
continue
|
||
}
|
||
metadata, _ := node["metadata"].(map[string]interface{})
|
||
if metadata == nil {
|
||
metadata = map[string]interface{}{}
|
||
}
|
||
nodeType := stringValue(node["type"])
|
||
isCharacterCard := stringValue(metadata["workflowKind"]) == "character" && stringValue(metadata["characterAssetId"]) != "" && stringValue(metadata["characterVersionId"]) != ""
|
||
if nodeType != "image" && !isCharacterCard {
|
||
continue
|
||
}
|
||
id := stringValue(node["id"])
|
||
if id == "" {
|
||
continue
|
||
}
|
||
tags := stringSlice(metadata["assetTags"])
|
||
prompt := stringValue(metadata["prompt"])
|
||
content := stringValue(metadata["content"])
|
||
if len(tags) == 0 && prompt == "" && content == "" && !isCharacterCard {
|
||
continue
|
||
}
|
||
assets = append(assets, storyboardAsset{
|
||
ID: id,
|
||
Title: defaultString(stringValue(node["title"]), "未命名图片"),
|
||
Type: defaultString(nodeType, "reference"),
|
||
Tags: tags,
|
||
Prompt: prompt,
|
||
CharacterAssetID: stringValue(metadata["characterAssetId"]),
|
||
CharacterVersionID: stringValue(metadata["characterVersionId"]),
|
||
})
|
||
if len(assets) >= 30 {
|
||
break
|
||
}
|
||
}
|
||
return assets
|
||
}
|
||
|
||
func matchStoryboardAssets(assets []storyboardAsset, shotTags []string) []storyboardAsset {
|
||
wanted := map[string]bool{}
|
||
for _, tag := range shotTags {
|
||
for _, token := range storyboardTagTokens(tag) {
|
||
wanted[token] = true
|
||
}
|
||
}
|
||
if len(wanted) == 0 {
|
||
return nil
|
||
}
|
||
matched := make([]storyboardAsset, 0)
|
||
for _, asset := range assets {
|
||
tokens := map[string]bool{}
|
||
for _, token := range storyboardTagTokens(asset.Title) {
|
||
tokens[token] = true
|
||
}
|
||
for _, tag := range asset.Tags {
|
||
for _, token := range storyboardTagTokens(tag) {
|
||
tokens[token] = true
|
||
}
|
||
}
|
||
if storyboardTokensMatch(wanted, tokens) {
|
||
matched = append(matched, asset)
|
||
}
|
||
if len(matched) >= 6 {
|
||
break
|
||
}
|
||
}
|
||
return matched
|
||
}
|
||
|
||
func matchStoryboardAssetsForShot(assets []storyboardAsset, shot agentStoryboardShot) []storyboardAsset {
|
||
matched := make([]storyboardAsset, 0, 6)
|
||
seen := make(map[string]bool, 6)
|
||
wantedCharacters := make(map[string]bool, len(shot.CharacterIDs))
|
||
for _, assetID := range shot.CharacterIDs {
|
||
wantedCharacters[assetID] = true
|
||
}
|
||
for _, asset := range assets {
|
||
if len(matched) >= 6 {
|
||
break
|
||
}
|
||
if !seen[asset.ID] && wantedCharacters[asset.CharacterAssetID] {
|
||
matched = append(matched, asset)
|
||
seen[asset.ID] = true
|
||
}
|
||
}
|
||
for _, asset := range matchStoryboardAssets(assets, shot.AssetTags) {
|
||
if len(matched) >= 6 {
|
||
break
|
||
}
|
||
if !seen[asset.ID] {
|
||
matched = append(matched, asset)
|
||
seen[asset.ID] = true
|
||
}
|
||
}
|
||
return matched
|
||
}
|
||
|
||
func storyboardTokensMatch(wanted map[string]bool, tokens map[string]bool) bool {
|
||
for want := range wanted {
|
||
if tokens[want] {
|
||
return true
|
||
}
|
||
for token := range tokens {
|
||
if meaningfulStoryboardTagToken(want) && meaningfulStoryboardTagToken(token) && (strings.Contains(token, want) || strings.Contains(want, token)) {
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func storyboardTagTokens(value string) []string {
|
||
normalized := strings.ToLower(strings.ReplaceAll(strings.Join(strings.Fields(strings.ReplaceAll(value, "：", ":")), ""), "，", ","))
|
||
if normalized == "" {
|
||
return nil
|
||
}
|
||
tokens := []string{normalized}
|
||
if index := strings.Index(normalized, ":"); index >= 0 {
|
||
tokens = append(tokens, normalized[index+1:])
|
||
}
|
||
unique := make([]string, 0, len(tokens))
|
||
seen := map[string]bool{}
|
||
for _, token := range tokens {
|
||
if meaningfulStoryboardTagToken(token) && !seen[token] {
|
||
seen[token] = true
|
||
unique = append(unique, token)
|
||
}
|
||
}
|
||
return unique
|
||
}
|
||
|
||
func meaningfulStoryboardTagToken(value string) bool {
|
||
if len([]rune(value)) < 2 {
|
||
return false
|
||
}
|
||
switch value {
|
||
case "角色", "环境", "场景", "道具", "武器", "风格":
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
func listContent(title string, items []string) string {
|
||
if len(items) == 0 {
|
||
return title + "\n\n- 暂无明确内容。"
|
||
}
|
||
lines := []string{title, ""}
|
||
for _, item := range items {
|
||
if strings.TrimSpace(item) != "" {
|
||
lines = append(lines, "- "+item)
|
||
}
|
||
}
|
||
return strings.Join(lines, "\n")
|
||
}
|
||
|
||
func storyboardAssetsContent(assets []storyboardAsset) string {
|
||
if len(assets) == 0 {
|
||
return "当前画布暂无可用图片资产。建议先给角色、环境、道具图片添加资产标签。"
|
||
}
|
||
lines := make([]string, 0, len(assets))
|
||
for _, asset := range assets {
|
||
line := asset.Title + "\nID: " + asset.ID
|
||
if len(asset.Tags) > 0 {
|
||
line += "\n标签: " + strings.Join(asset.Tags, "、")
|
||
}
|
||
if asset.Prompt != "" {
|
||
line += "\n原提示词: " + asset.Prompt
|
||
}
|
||
lines = append(lines, line)
|
||
}
|
||
return strings.Join(lines, "\n\n")
|
||
}
|
||
|
||
func shotDescription(shot agentStoryboardShot) string {
|
||
parts := []string{shot.Description}
|
||
if strings.TrimSpace(shot.VisualPrompt) != "" {
|
||
parts = append(parts, "画面提示词："+shot.VisualPrompt)
|
||
}
|
||
if strings.TrimSpace(shot.Camera) != "" {
|
||
parts = append(parts, "镜头："+shot.Camera)
|
||
}
|
||
if strings.TrimSpace(shot.Motion) != "" {
|
||
parts = append(parts, "运动："+shot.Motion)
|
||
}
|
||
if strings.TrimSpace(shot.TimeBeats) != "" {
|
||
parts = append(parts, "时间节拍："+shot.TimeBeats)
|
||
}
|
||
filtered := make([]string, 0, len(parts))
|
||
for _, part := range parts {
|
||
if strings.TrimSpace(part) != "" {
|
||
filtered = append(filtered, part)
|
||
}
|
||
}
|
||
return strings.Join(filtered, "\n\n")
|
||
}
|
||
|
||
func storyboardImagePromptValues(projectStyle string, styleGuide string, shot agentStoryboardShot) map[string]string {
|
||
negative := defaultString(strings.TrimSpace(shot.Negative), "禁止换脸、服装变化、手部畸形、乱码、风格突变和塑料材质")
|
||
return map[string]string{
|
||
"项目视觉": storyboardProjectVisualSummary(projectStyle, styleGuide),
|
||
"首帧构图": compactPromptText(shot.VisualPrompt+"；光影："+shot.Lighting, 360),
|
||
"表演起始状态": compactPromptText(shot.Performance, 180),
|
||
"负面要求": compactPromptText(negative, 140),
|
||
}
|
||
}
|
||
|
||
func buildStoryboardImagePrompt(projectStyle string, styleGuide string, shot agentStoryboardShot) string {
|
||
definition, _ := promptDefinition(promptOperationStoryboardFirstFrame)
|
||
prompt, _ := renderPromptTemplate(definition, definition.DefaultContent, storyboardImagePromptValues(projectStyle, styleGuide, shot))
|
||
return prompt
|
||
}
|
||
|
||
func (s *Service) compileStoryboardImagePrompt(userID string, projectStyle string, styleGuide string, shot agentStoryboardShot) (string, error) {
|
||
compiled, err := s.compilePrompt(userID, promptOperationStoryboardFirstFrame, storyboardImagePromptValues(projectStyle, styleGuide, shot))
|
||
return compiled.Content, err
|
||
}
|
||
|
||
func storyboardVideoPromptValues(projectStyle string, styleGuide string, shot agentStoryboardShot) map[string]string {
|
||
camera := defaultString(strings.TrimSpace(shot.Camera), strings.TrimSpace(shot.ShotSize)+"，平视机位，中等焦段，主体与环境保持空间层次")
|
||
motion := defaultString(strings.TrimSpace(shot.Motion), "固定机位，主体在画面内完成动作")
|
||
timeBeats := defaultString(strings.TrimSpace(shot.TimeBeats), fmt.Sprintf("0-%d秒：%s", shot.Duration, strings.TrimSpace(shot.Description)))
|
||
negative := defaultString(strings.TrimSpace(shot.Negative), "禁止换脸、服装变化、手部畸形、乱码、闪烁、风格突变和动作僵硬")
|
||
values := map[string]string{
|
||
"项目视觉": storyboardProjectVisualSummary(projectStyle, styleGuide),
|
||
"镜头意图": compactPromptText(shot.Intent+"；观众视点："+shot.ViewerPOV+"；情绪："+shot.Emotion, 150),
|
||
"首帧构图": compactPromptText(shot.VisualPrompt+"；光影："+shot.Lighting, 280),
|
||
"表演与调度": compactPromptText(shot.Performance, 180),
|
||
"摄影机": compactPromptText(strings.TrimSpace(shot.ShotSize)+"；"+camera+"；主运镜："+motion, 220),
|
||
"时间节拍": compactPromptText(timeBeats, 240),
|
||
"运动与结尾": compactPromptText(shot.VideoPrompt+"；连续性结尾："+shot.ContinuityOut, 240),
|
||
"声音": compactPromptText(strings.TrimSpace(shot.Dialogue)+"；音效："+strings.TrimSpace(shot.AudioEffects), 160),
|
||
"负面要求": compactPromptText(negative, 160),
|
||
}
|
||
if len(shot.MustHave) > 0 {
|
||
priority := "必须完成：" + strings.Join(shot.MustHave, "；")
|
||
if len(shot.Optional) > 0 {
|
||
priority += "。可以简化：" + strings.Join(shot.Optional, "；")
|
||
}
|
||
values["执行优先级"] = compactPromptText(priority, 140)
|
||
}
|
||
return values
|
||
}
|
||
|
||
func buildStoryboardVideoPrompt(projectStyle string, styleGuide string, shot agentStoryboardShot) string {
|
||
definition, _ := promptDefinition(promptOperationStoryboardVideo)
|
||
prompt, _ := renderPromptTemplate(definition, definition.DefaultContent, storyboardVideoPromptValues(projectStyle, styleGuide, shot))
|
||
return prompt
|
||
}
|
||
|
||
func (s *Service) compileStoryboardVideoPrompt(userID string, projectStyle string, styleGuide string, shot agentStoryboardShot) (string, error) {
|
||
compiled, err := s.compilePrompt(userID, promptOperationStoryboardVideo, storyboardVideoPromptValues(projectStyle, styleGuide, shot))
|
||
return compiled.Content, err
|
||
}
|
||
|
||
func storyboardProjectVisualSummary(projectStyle string, styleGuide string) string {
|
||
identity := ""
|
||
for _, line := range strings.Split(projectStyle, "\n") {
|
||
if strings.TrimSpace(line) != "" {
|
||
identity = strings.TrimSpace(line)
|
||
break
|
||
}
|
||
}
|
||
parts := make([]string, 0, 2)
|
||
if identity != "" {
|
||
parts = append(parts, identity)
|
||
}
|
||
if strings.TrimSpace(styleGuide) != "" {
|
||
parts = append(parts, strings.TrimSpace(styleGuide))
|
||
}
|
||
return compactPromptText(strings.Join(parts, "；"), 180)
|
||
}
|
||
|
||
func compactPromptText(value string, limit int) string {
|
||
text := strings.TrimSpace(value)
|
||
if utf8.RuneCountInString(text) <= limit {
|
||
return text
|
||
}
|
||
runes := []rune(text)
|
||
return strings.TrimSpace(string(runes[:limit])) + "。"
|
||
}
|
||
|
||
func shotComposerContent(prompt string, assets []storyboardAsset) string {
|
||
if len(assets) == 0 {
|
||
return prompt
|
||
}
|
||
lines := []string{"参考素材："}
|
||
for _, asset := range assets {
|
||
label := asset.Title
|
||
if len(asset.Tags) > 0 {
|
||
label += "（" + strings.Join(asset.Tags, "、") + "）"
|
||
}
|
||
lines = append(lines, "- "+label+"：@[node:"+asset.ID+"]")
|
||
}
|
||
lines = append(lines, "", "分镜视频提示词：", prompt)
|
||
return strings.Join(lines, "\n")
|
||
}
|
||
|
||
func shotIDs(prefix string, count int) []string {
|
||
ids := make([]string, 0, count)
|
||
for index := 0; index < count; index++ {
|
||
ids = append(ids, fmt.Sprintf("%s-shot-%d", prefix, index+1))
|
||
}
|
||
return ids
|
||
}
|
||
|
||
func stringSlice(value any) []string {
|
||
items, ok := value.([]interface{})
|
||
if !ok {
|
||
text := stringValue(value)
|
||
if text == "" {
|
||
return nil
|
||
}
|
||
return []string{text}
|
||
}
|
||
result := make([]string, 0, len(items))
|
||
for _, item := range items {
|
||
if text := strings.TrimSpace(fmt.Sprint(item)); text != "" {
|
||
result = append(result, text)
|
||
}
|
||
}
|
||
return result
|
||
}
|
||
|
||
func stringValue(value any) string {
|
||
text := strings.TrimSpace(fmt.Sprint(value))
|
||
if text == "<nil>" {
|
||
return ""
|
||
}
|
||
return text
|
||
}
|
||
|
||
func (s *Service) log(userID string, taskID string, level string, message string, payload string) error {
|
||
return s.repo.Create(&model.TaskLog{ID: newID(), UserID: userID, TaskID: taskID, Level: level, Message: message, Payload: truncateTaskLogPayload(payload)})
|
||
}
|
||
|
||
func truncateTaskLogPayload(payload string) string {
|
||
if len(payload) <= taskLogPayloadLimit {
|
||
return payload
|
||
}
|
||
end := taskLogPayloadLimit
|
||
for end > 0 && !utf8.ValidString(payload[:end]) {
|
||
end--
|
||
}
|
||
return payload[:end] + fmt.Sprintf("\n...（日志内容已截断，原始长度 %d 字符）", len(payload))
|
||
}
|
||
|
||
func (s *Service) registerActiveTask(id string, cancel context.CancelFunc) {
|
||
s.cancelMu.Lock()
|
||
defer s.cancelMu.Unlock()
|
||
s.activeCancels[id] = cancel
|
||
}
|
||
|
||
func (s *Service) unregisterActiveTask(id string) {
|
||
s.cancelMu.Lock()
|
||
defer s.cancelMu.Unlock()
|
||
delete(s.activeCancels, id)
|
||
}
|
||
|
||
func (s *Service) cancelActiveTask(id string) {
|
||
s.cancelMu.Lock()
|
||
cancel := s.activeCancels[id]
|
||
s.cancelMu.Unlock()
|
||
if cancel != nil {
|
||
cancel()
|
||
}
|
||
}
|
||
|
||
func (s *Service) markSessionFailed(task model.Task, message string) error {
|
||
if task.SessionID == "" {
|
||
return nil
|
||
}
|
||
session, err := s.repo.SessionForUser(task.UserID, task.SessionID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
session.Status = model.SessionStatusFailed
|
||
if err := s.repo.Save(session); err != nil {
|
||
return err
|
||
}
|
||
return s.repo.Create(&model.Message{ID: newID(), UserID: task.UserID, SessionID: task.SessionID, Role: "assistant", Content: defaultString(message, "会话任务失败。")})
|
||
}
|
||
func nodeOp(id string, nodeType string, title string, x int, y int, workflowKind string, content string) map[string]any {
|
||
return nodeOpWithMetadata(id, nodeType, title, x, y, map[string]any{"content": content, "workflowKind": workflowKind, "status": "idle"})
|
||
}
|
||
|
||
func nodeOpWithMetadata(id string, nodeType string, title string, x int, y int, metadata map[string]any) map[string]any {
|
||
return map[string]any{
|
||
"type": "add_node",
|
||
"id": id,
|
||
"nodeType": nodeType,
|
||
"title": title,
|
||
"position": map[string]int{"x": x, "y": y},
|
||
"metadata": metadata,
|
||
}
|
||
}
|
||
|
||
func connectOp(from string, to string) map[string]any {
|
||
return map[string]any{"type": "connect_nodes", "fromNodeId": from, "toNodeId": to}
|
||
}
|
||
|
||
func ptr[T any](value T) *T {
|
||
return &value
|
||
}
|
||
|
||
func shortTitle(value string, max int) string {
|
||
title := strings.TrimSpace(value)
|
||
if title == "" {
|
||
title = "影视分镜"
|
||
}
|
||
if len([]rune(title)) > max {
|
||
return string([]rune(title)[:max]) + "..."
|
||
}
|
||
return title
|
||
}
|
||
|
||
func defaultString(value string, fallback string) string {
|
||
if strings.TrimSpace(value) == "" {
|
||
return fallback
|
||
}
|
||
return value
|
||
}
|
||
|
||
func newID() string {
|
||
var b [16]byte
|
||
if _, err := rand.Read(b[:]); err != nil {
|
||
return fmt.Sprintf("%d", time.Now().UnixNano())
|
||
}
|
||
return hex.EncodeToString(b[:])
|
||
}
|