From 480063f5b234998f0b65ed40cdc79de4b60a7ed4 Mon Sep 17 00:00:00 2001 From: Max Date: Sun, 18 Jan 2026 16:38:30 +0800 Subject: [PATCH] Enhance Execution Record Model and Storage Implementation - Updated the ExecutionRecord structure in TECHNICAL.md to include new fields such as ExecutionID and improved status tracking with cancellation support. - Revised the ExecutionStore implementation in store/execution.go to add methods for updating execution status and current state, as well as deleting records. - Marked the completion of the execution record model in TODO.md, reflecting the integration of new features and ensuring comprehensive tracking of execution history. - Updated bindata.go and model.go to include the new execution model, enhancing the overall architecture for better data management. --- agent/robot/TECHNICAL.md | 107 ++-- agent/robot/TODO.md | 56 +- agent/robot/store/execution.go | 719 +++++++++++++++++++++++++ agent/robot/store/execution_test.go | 791 ++++++++++++++++++++++++++++ data/bindata.go | 353 +++++++------ model/model.go | 1 + test/utils.go | 1 + yao/models/agent/execution.mod.yao | 207 ++++++++ 8 files changed, 2004 insertions(+), 231 deletions(-) create mode 100644 agent/robot/store/execution.go create mode 100644 agent/robot/store/execution_test.go create mode 100644 yao/models/agent/execution.mod.yao diff --git a/agent/robot/TECHNICAL.md b/agent/robot/TECHNICAL.md index b896dda0..fdec87b0 100644 --- a/agent/robot/TECHNICAL.md +++ b/agent/robot/TECHNICAL.md @@ -2353,63 +2353,88 @@ Robot execution history is stored in `__yao.agent_execution` table for UI displa // Table: __yao.agent_execution type ExecutionRecord struct { - ID string `json:"id"` // Execution ID - RobotID string `json:"robot_id"` // Robot config ID - MemberID string `json:"member_id"` // Robot member ID (user identity) - TeamID string `json:"team_id"` // Team ID - JobID string `json:"job_id"` // Linked job.Job ID - TriggerType TriggerType `json:"trigger_type"` // clock | human | event + ID int64 `json:"id,omitempty"` // Auto-increment primary key + ExecutionID string `json:"execution_id"` // Unique execution identifier + RobotID string `json:"robot_id"` // Robot config ID + MemberID string `json:"member_id"` // Robot member ID (user identity) + TeamID string `json:"team_id"` // Team ID + JobID string `json:"job_id,omitempty"` // Linked job.Job ID + TriggerType TriggerType `json:"trigger_type"` // clock | human | event // Status tracking (synced with runtime Execution) - Status ExecStatus `json:"status"` // pending | running | completed | failed - Phase Phase `json:"phase"` // Current phase - Current *CurrentState `json:"current"` // Current executing state (task index, progress) - Error string `json:"error"` // Error message if failed + Status ExecStatus `json:"status"` // pending | running | completed | failed | cancelled + Phase Phase `json:"phase"` // Current phase + Current *CurrentState `json:"current,omitempty"`// Current executing state (task index, progress) + Error string `json:"error,omitempty"` // Error message if failed // Trigger input - Input *TriggerInput `json:"input"` // Original trigger input + Input *TriggerInput `json:"input,omitempty"` // Original trigger input // Phase outputs (P0-P5) - Inspiration *InspirationReport `json:"inspiration"` // P0 result - Goals *Goals `json:"goals"` // P1 result - Tasks []Task `json:"tasks"` // P2 result - Results []TaskResult `json:"results"` // P3 results - Delivery *DeliveryResult `json:"delivery"` // P4 result - Learning []LearningEntry `json:"learning"` // P5 entries + Inspiration *InspirationReport `json:"inspiration,omitempty"` // P0 result + Goals *Goals `json:"goals,omitempty"` // P1 result + Tasks []Task `json:"tasks,omitempty"` // P2 result + Results []TaskResult `json:"results,omitempty"` // P3 results + Delivery *DeliveryResult `json:"delivery,omitempty"` // P4 result + Learning []LearningEntry `json:"learning,omitempty"` // P5 entries // Timestamps - StartTime time.Time `json:"start_time"` - EndTime *time.Time `json:"end_time"` - CreatedAt time.Time `json:"created_at"` - UpdatedAt time.Time `json:"updated_at"` + StartTime *time.Time `json:"start_time,omitempty"` + EndTime *time.Time `json:"end_time,omitempty"` + CreatedAt *time.Time `json:"created_at,omitempty"` + UpdatedAt *time.Time `json:"updated_at,omitempty"` +} + +// CurrentState - current executing state (for JSON storage) +type CurrentState struct { + TaskIndex int `json:"task_index"` // index in Tasks slice + Progress string `json:"progress,omitempty"` // human-readable progress (e.g., "2/5 tasks") } ``` -**Store Interface:** +**Store Implementation:** ```go // store/execution.go -type ExecutionStore interface { - // Save creates or updates an execution record - Save(ctx context.Context, record *ExecutionRecord) error - - // Get retrieves an execution by ID - Get(ctx context.Context, execID string) (*ExecutionRecord, error) - - // List retrieves executions with filters - List(ctx context.Context, opts ListOptions) ([]*ExecutionRecord, int, error) - - // UpdatePhase updates the current phase - UpdatePhase(ctx context.Context, execID string, phase Phase, data interface{}) error +type ExecutionStore struct { + modelID string // "__yao.agent.execution" } +func NewExecutionStore() *ExecutionStore + +// Save creates or updates an execution record +func (s *ExecutionStore) Save(ctx context.Context, record *ExecutionRecord) error + +// Get retrieves an execution by execution_id +func (s *ExecutionStore) Get(ctx context.Context, executionID string) (*ExecutionRecord, error) + +// List retrieves executions with filters +func (s *ExecutionStore) List(ctx context.Context, opts *ListOptions) ([]*ExecutionRecord, error) + +// UpdatePhase updates the current phase and its data +func (s *ExecutionStore) UpdatePhase(ctx context.Context, executionID string, phase Phase, data interface{}) error + +// UpdateStatus updates the execution status +func (s *ExecutionStore) UpdateStatus(ctx context.Context, executionID string, status ExecStatus, errorMsg string) error + +// UpdateCurrent updates the current executing state +func (s *ExecutionStore) UpdateCurrent(ctx context.Context, executionID string, current *CurrentState) error + +// Delete removes an execution record +func (s *ExecutionStore) Delete(ctx context.Context, executionID string) error + +// Conversion helpers +func FromExecution(exec *Execution, robotID string) *ExecutionRecord +func (r *ExecutionRecord) ToExecution() *Execution + type ListOptions struct { - RobotID string // Filter by robot config ID - MemberID string // Filter by robot member ID - TeamID string // Filter by team - Status ExecStatus // Filter by status - TriggerType TriggerType // Filter by trigger - Page int - PageSize int + RobotID string // Filter by robot config ID + MemberID string // Filter by robot member ID + TeamID string // Filter by team + Status ExecStatus // Filter by status + TriggerType TriggerType // Filter by trigger + Limit int // Max records to return (default: 100) + Offset int // Skip records for pagination + OrderBy string // e.g., "start_time desc" } ``` diff --git a/agent/robot/TODO.md b/agent/robot/TODO.md index 06c1576c..7e33c2e8 100644 --- a/agent/robot/TODO.md +++ b/agent/robot/TODO.md @@ -869,34 +869,40 @@ Created new `yao/assert` package for universal assertion/validation: **Depends on:** Phase 9 (P3 Run) -### 10.1 Execution Persistence (Prerequisite) +### 10.1 Execution Persistence (Prerequisite) ✅ > **Background:** Each Robot execution (P0-P5) needs persistent storage for UI history queries. -- [ ] `yao/models/agent/execution.mod.yao` - Execution record model (`agent_execution` table) - - [ ] id, execution_id (unique) - - [ ] robot_id, member_id, team_id, job_id - - [ ] trigger_type (enum: clock, human, event) - - [ ] **Status tracking** (synced with runtime Execution): - - [ ] status (enum: pending, running, completed, failed, cancelled) - - [ ] phase (enum: inspiration, goals, tasks, run, delivery, learning) - - [ ] current (JSON) - current executing state (task_index, progress) - - [ ] error - error message if failed - - [ ] input (JSON) - trigger input - - [ ] **Phase outputs** (P0-P5): - - [ ] inspiration (JSON) - P0 output - - [ ] goals (JSON) - P1 output - - [ ] tasks (JSON) - P2 output - - [ ] results (JSON) - P3 output - - [ ] delivery (JSON) - P4 output - - [ ] learning (JSON) - P5 output - - [ ] **Timestamps**: start_time, end_time, created_at, updated_at - - [ ] Relations: member (hasOne __yao.member) -- [ ] `agent/robot/store/execution.go` - Execution record storage - - [ ] `Save(ctx, record)` - create or update execution record - - [ ] `Get(ctx, execID)` - get execution by ID - - [ ] `List(ctx, opts)` - query execution history with filters - - [ ] `UpdatePhase(ctx, execID, phase, data)` - update current phase and data +- [x] `yao/models/agent/execution.mod.yao` - Execution record model (`agent_execution` table) + - [x] id, execution_id (unique) + - [x] robot_id, member_id, team_id, job_id + - [x] trigger_type (enum: clock, human, event) + - [x] **Status tracking** (synced with runtime Execution): + - [x] status (enum: pending, running, completed, failed, cancelled) + - [x] phase (enum: inspiration, goals, tasks, run, delivery, learning) + - [x] current (JSON) - current executing state (task_index, progress) + - [x] error - error message if failed + - [x] input (JSON) - trigger input + - [x] **Phase outputs** (P0-P5): + - [x] inspiration (JSON) - P0 output + - [x] goals (JSON) - P1 output + - [x] tasks (JSON) - P2 output + - [x] results (JSON) - P3 output + - [x] delivery (JSON) - P4 output + - [x] learning (JSON) - P5 output + - [x] **Timestamps**: start_time, end_time, created_at, updated_at + - [x] Relations: member (hasOne __yao.member) +- [x] `agent/robot/store/execution.go` - Execution record storage + - [x] `Save(ctx, record)` - create or update execution record + - [x] `Get(ctx, execID)` - get execution by ID + - [x] `List(ctx, opts)` - query execution history with filters + - [x] `UpdatePhase(ctx, execID, phase, data)` - update current phase and data + - [x] `UpdateStatus(ctx, execID, status, error)` - update execution status + - [x] `UpdateCurrent(ctx, execID, current)` - update current executing state + - [x] `Delete(ctx, execID)` - delete execution record + - [x] `FromExecution(exec, robotID)` - convert runtime Execution to record + - [x] `ToExecution()` - convert record to runtime Execution +- [x] Tests: `agent/robot/store/execution_test.go` (9 test groups, all passing) - [ ] Integrate into Executor - call `UpdatePhase()` after each phase completes ### 10.2 Messenger Attachment Support ✅ diff --git a/agent/robot/store/execution.go b/agent/robot/store/execution.go new file mode 100644 index 00000000..ef19d269 --- /dev/null +++ b/agent/robot/store/execution.go @@ -0,0 +1,719 @@ +package store + +import ( + "context" + "encoding/json" + "fmt" + "time" + + "github.com/yaoapp/gou/model" + "github.com/yaoapp/yao/agent/robot/types" +) + +// ExecutionRecord - persistent storage for robot execution history +// Maps to __yao.agent_execution model +type ExecutionRecord struct { + ID int64 `json:"id,omitempty"` // Auto-increment primary key + ExecutionID string `json:"execution_id"` // Unique execution identifier + RobotID string `json:"robot_id"` // Robot config ID + MemberID string `json:"member_id"` // Robot member ID (user identity) + TeamID string `json:"team_id"` // Team ID + JobID string `json:"job_id,omitempty"` // Linked job.Job ID + TriggerType types.TriggerType `json:"trigger_type"` // clock | human | event + + // Status tracking (synced with runtime Execution) + Status types.ExecStatus `json:"status"` // pending | running | completed | failed | cancelled + Phase types.Phase `json:"phase"` // Current phase + Current *CurrentState `json:"current,omitempty"` + Error string `json:"error,omitempty"` + + // Trigger input + Input *types.TriggerInput `json:"input,omitempty"` + + // Phase outputs (P0-P5) + Inspiration *types.InspirationReport `json:"inspiration,omitempty"` + Goals *types.Goals `json:"goals,omitempty"` + Tasks []types.Task `json:"tasks,omitempty"` + Results []types.TaskResult `json:"results,omitempty"` + Delivery *types.DeliveryResult `json:"delivery,omitempty"` + Learning []types.LearningEntry `json:"learning,omitempty"` + + // Timestamps + StartTime *time.Time `json:"start_time,omitempty"` + EndTime *time.Time `json:"end_time,omitempty"` + CreatedAt *time.Time `json:"created_at,omitempty"` + UpdatedAt *time.Time `json:"updated_at,omitempty"` +} + +// CurrentState - current executing state (for JSON storage) +type CurrentState struct { + TaskIndex int `json:"task_index"` // index in Tasks slice + Progress string `json:"progress,omitempty"` // human-readable progress (e.g., "2/5 tasks") +} + +// ListOptions - options for listing execution records +type ListOptions struct { + RobotID string `json:"robot_id,omitempty"` + MemberID string `json:"member_id,omitempty"` + TeamID string `json:"team_id,omitempty"` + Status types.ExecStatus `json:"status,omitempty"` + TriggerType types.TriggerType `json:"trigger_type,omitempty"` + Limit int `json:"limit,omitempty"` + Offset int `json:"offset,omitempty"` + OrderBy string `json:"order_by,omitempty"` // e.g., "start_time desc" +} + +// ExecutionStore - persistent storage for robot execution records +type ExecutionStore struct { + modelID string +} + +// NewExecutionStore creates a new execution store instance +func NewExecutionStore() *ExecutionStore { + return &ExecutionStore{ + modelID: "__yao.agent.execution", + } +} + +// Save creates or updates an execution record +func (s *ExecutionStore) Save(ctx context.Context, record *ExecutionRecord) error { + mod := model.Select(s.modelID) + if mod == nil { + return fmt.Errorf("model %s not found", s.modelID) + } + + data := s.recordToMap(record) + + // Check if record exists by execution_id + existing, err := s.Get(ctx, record.ExecutionID) + if err == nil && existing != nil { + // Update existing record + _, err = mod.UpdateWhere( + model.QueryParam{ + Wheres: []model.QueryWhere{ + {Column: "execution_id", Value: record.ExecutionID}, + }, + }, + data, + ) + if err != nil { + return fmt.Errorf("failed to update execution record: %w", err) + } + return nil + } + + // Create new record + _, err = mod.Create(data) + if err != nil { + return fmt.Errorf("failed to create execution record: %w", err) + } + return nil +} + +// Get retrieves an execution record by execution_id +func (s *ExecutionStore) Get(ctx context.Context, executionID string) (*ExecutionRecord, error) { + mod := model.Select(s.modelID) + if mod == nil { + return nil, fmt.Errorf("model %s not found", s.modelID) + } + + rows, err := mod.Get(model.QueryParam{ + Wheres: []model.QueryWhere{ + {Column: "execution_id", Value: executionID}, + }, + Limit: 1, + }) + if err != nil { + return nil, fmt.Errorf("failed to get execution record: %w", err) + } + + if len(rows) == 0 { + return nil, nil + } + + return s.mapToRecord(rows[0]) +} + +// List retrieves execution records with filters +func (s *ExecutionStore) List(ctx context.Context, opts *ListOptions) ([]*ExecutionRecord, error) { + mod := model.Select(s.modelID) + if mod == nil { + return nil, fmt.Errorf("model %s not found", s.modelID) + } + + params := model.QueryParam{} + + // Build where conditions + var wheres []model.QueryWhere + if opts != nil { + if opts.RobotID != "" { + wheres = append(wheres, model.QueryWhere{Column: "robot_id", Value: opts.RobotID}) + } + if opts.MemberID != "" { + wheres = append(wheres, model.QueryWhere{Column: "member_id", Value: opts.MemberID}) + } + if opts.TeamID != "" { + wheres = append(wheres, model.QueryWhere{Column: "team_id", Value: opts.TeamID}) + } + if opts.Status != "" { + wheres = append(wheres, model.QueryWhere{Column: "status", Value: string(opts.Status)}) + } + if opts.TriggerType != "" { + wheres = append(wheres, model.QueryWhere{Column: "trigger_type", Value: string(opts.TriggerType)}) + } + + params.Limit = opts.Limit + if params.Limit == 0 { + params.Limit = 100 // default limit + } + + // Note: model.QueryParam doesn't have Offset, use Page instead + if opts.Offset > 0 && opts.Limit > 0 { + params.Page = (opts.Offset / opts.Limit) + 1 + } + + if opts.OrderBy != "" { + // Parse OrderBy: "column desc" or "column asc" or just "column" + parts := splitOrderBy(opts.OrderBy) + params.Orders = []model.QueryOrder{{Column: parts[0], Option: parts[1]}} + } else { + params.Orders = []model.QueryOrder{{Column: "start_time", Option: "desc"}} + } + } else { + params.Limit = 100 + params.Orders = []model.QueryOrder{{Column: "start_time", Option: "desc"}} + } + + params.Wheres = wheres + + rows, err := mod.Get(params) + if err != nil { + return nil, fmt.Errorf("failed to list execution records: %w", err) + } + + records := make([]*ExecutionRecord, 0, len(rows)) + for _, row := range rows { + record, err := s.mapToRecord(row) + if err != nil { + continue // skip invalid records + } + records = append(records, record) + } + + return records, nil +} + +// UpdatePhase updates the current phase and its data +func (s *ExecutionStore) UpdatePhase(ctx context.Context, executionID string, phase types.Phase, data interface{}) error { + mod := model.Select(s.modelID) + if mod == nil { + return fmt.Errorf("model %s not found", s.modelID) + } + + updateData := map[string]interface{}{ + "phase": string(phase), + } + + // Set the appropriate phase output field + switch phase { + case types.PhaseInspiration: + if data != nil { + updateData["inspiration"] = data + } + case types.PhaseGoals: + if data != nil { + updateData["goals"] = data + } + case types.PhaseTasks: + if data != nil { + updateData["tasks"] = data + } + case types.PhaseRun: + if data != nil { + updateData["results"] = data + } + case types.PhaseDelivery: + if data != nil { + updateData["delivery"] = data + } + case types.PhaseLearning: + if data != nil { + updateData["learning"] = data + } + } + + _, err := mod.UpdateWhere( + model.QueryParam{ + Wheres: []model.QueryWhere{ + {Column: "execution_id", Value: executionID}, + }, + }, + updateData, + ) + if err != nil { + return fmt.Errorf("failed to update phase: %w", err) + } + + return nil +} + +// UpdateStatus updates the execution status +func (s *ExecutionStore) UpdateStatus(ctx context.Context, executionID string, status types.ExecStatus, errorMsg string) error { + mod := model.Select(s.modelID) + if mod == nil { + return fmt.Errorf("model %s not found", s.modelID) + } + + updateData := map[string]interface{}{ + "status": string(status), + } + + if errorMsg != "" { + updateData["error"] = errorMsg + } + + // Set end_time for terminal states + if status == types.ExecCompleted || status == types.ExecFailed || status == types.ExecCancelled { + now := time.Now() + updateData["end_time"] = now + } + + _, err := mod.UpdateWhere( + model.QueryParam{ + Wheres: []model.QueryWhere{ + {Column: "execution_id", Value: executionID}, + }, + }, + updateData, + ) + if err != nil { + return fmt.Errorf("failed to update status: %w", err) + } + + return nil +} + +// UpdateCurrent updates the current executing state +func (s *ExecutionStore) UpdateCurrent(ctx context.Context, executionID string, current *CurrentState) error { + mod := model.Select(s.modelID) + if mod == nil { + return fmt.Errorf("model %s not found", s.modelID) + } + + updateData := map[string]interface{}{ + "current": current, + } + + _, err := mod.UpdateWhere( + model.QueryParam{ + Wheres: []model.QueryWhere{ + {Column: "execution_id", Value: executionID}, + }, + }, + updateData, + ) + if err != nil { + return fmt.Errorf("failed to update current state: %w", err) + } + + return nil +} + +// Delete removes an execution record by execution_id +func (s *ExecutionStore) Delete(ctx context.Context, executionID string) error { + mod := model.Select(s.modelID) + if mod == nil { + return fmt.Errorf("model %s not found", s.modelID) + } + + _, err := mod.DeleteWhere(model.QueryParam{ + Wheres: []model.QueryWhere{ + {Column: "execution_id", Value: executionID}, + }, + }) + if err != nil { + return fmt.Errorf("failed to delete execution record: %w", err) + } + + return nil +} + +// recordToMap converts ExecutionRecord to map for model operations +func (s *ExecutionStore) recordToMap(record *ExecutionRecord) map[string]interface{} { + data := map[string]interface{}{ + "execution_id": record.ExecutionID, + "member_id": record.MemberID, + "team_id": record.TeamID, + "trigger_type": string(record.TriggerType), + "status": string(record.Status), + "phase": string(record.Phase), + } + + if record.RobotID != "" { + data["robot_id"] = record.RobotID + } + if record.JobID != "" { + data["job_id"] = record.JobID + } + if record.Error != "" { + data["error"] = record.Error + } + if record.Current != nil { + data["current"] = record.Current + } + if record.Input != nil { + data["input"] = record.Input + } + if record.Inspiration != nil { + data["inspiration"] = record.Inspiration + } + if record.Goals != nil { + data["goals"] = record.Goals + } + if record.Tasks != nil { + data["tasks"] = record.Tasks + } + if record.Results != nil { + data["results"] = record.Results + } + if record.Delivery != nil { + data["delivery"] = record.Delivery + } + if record.Learning != nil { + data["learning"] = record.Learning + } + if record.StartTime != nil { + data["start_time"] = *record.StartTime + } + if record.EndTime != nil { + data["end_time"] = *record.EndTime + } + + return data +} + +// mapToRecord converts a model row to ExecutionRecord +func (s *ExecutionStore) mapToRecord(row map[string]interface{}) (*ExecutionRecord, error) { + record := &ExecutionRecord{} + + // Basic fields + if v, ok := row["id"]; ok { + switch id := v.(type) { + case float64: + record.ID = int64(id) + case int64: + record.ID = id + case int: + record.ID = int64(id) + } + } + if v, ok := row["execution_id"].(string); ok { + record.ExecutionID = v + } + if v, ok := row["robot_id"].(string); ok { + record.RobotID = v + } + if v, ok := row["member_id"].(string); ok { + record.MemberID = v + } + if v, ok := row["team_id"].(string); ok { + record.TeamID = v + } + if v, ok := row["job_id"].(string); ok { + record.JobID = v + } + if v, ok := row["trigger_type"].(string); ok { + record.TriggerType = types.TriggerType(v) + } + if v, ok := row["status"].(string); ok { + record.Status = types.ExecStatus(v) + } + if v, ok := row["phase"].(string); ok { + record.Phase = types.Phase(v) + } + if v, ok := row["error"].(string); ok { + record.Error = v + } + + // JSON fields - need to unmarshal + if v := row["current"]; v != nil { + record.Current = s.parseCurrentState(v) + } + if v := row["input"]; v != nil { + record.Input = s.parseTriggerInput(v) + } + if v := row["inspiration"]; v != nil { + record.Inspiration = s.parseInspirationReport(v) + } + if v := row["goals"]; v != nil { + record.Goals = s.parseGoals(v) + } + if v := row["tasks"]; v != nil { + record.Tasks = s.parseTasks(v) + } + if v := row["results"]; v != nil { + record.Results = s.parseResults(v) + } + if v := row["delivery"]; v != nil { + record.Delivery = s.parseDeliveryResult(v) + } + if v := row["learning"]; v != nil { + record.Learning = s.parseLearningEntries(v) + } + + // Timestamps + if v := row["start_time"]; v != nil { + record.StartTime = s.parseTime(v) + } + if v := row["end_time"]; v != nil { + record.EndTime = s.parseTime(v) + } + if v := row["created_at"]; v != nil { + record.CreatedAt = s.parseTime(v) + } + if v := row["updated_at"]; v != nil { + record.UpdatedAt = s.parseTime(v) + } + + return record, nil +} + +// Helper functions for parsing JSON fields + +func (s *ExecutionStore) parseCurrentState(v interface{}) *CurrentState { + data, err := s.toJSON(v) + if err != nil { + return nil + } + var state CurrentState + if err := json.Unmarshal(data, &state); err != nil { + return nil + } + return &state +} + +func (s *ExecutionStore) parseTriggerInput(v interface{}) *types.TriggerInput { + data, err := s.toJSON(v) + if err != nil { + return nil + } + var input types.TriggerInput + if err := json.Unmarshal(data, &input); err != nil { + return nil + } + return &input +} + +func (s *ExecutionStore) parseInspirationReport(v interface{}) *types.InspirationReport { + data, err := s.toJSON(v) + if err != nil { + return nil + } + var report types.InspirationReport + if err := json.Unmarshal(data, &report); err != nil { + return nil + } + return &report +} + +func (s *ExecutionStore) parseGoals(v interface{}) *types.Goals { + data, err := s.toJSON(v) + if err != nil { + return nil + } + var goals types.Goals + if err := json.Unmarshal(data, &goals); err != nil { + return nil + } + return &goals +} + +func (s *ExecutionStore) parseTasks(v interface{}) []types.Task { + data, err := s.toJSON(v) + if err != nil { + return nil + } + var tasks []types.Task + if err := json.Unmarshal(data, &tasks); err != nil { + return nil + } + return tasks +} + +func (s *ExecutionStore) parseResults(v interface{}) []types.TaskResult { + data, err := s.toJSON(v) + if err != nil { + return nil + } + var results []types.TaskResult + if err := json.Unmarshal(data, &results); err != nil { + return nil + } + return results +} + +func (s *ExecutionStore) parseDeliveryResult(v interface{}) *types.DeliveryResult { + data, err := s.toJSON(v) + if err != nil { + return nil + } + var result types.DeliveryResult + if err := json.Unmarshal(data, &result); err != nil { + return nil + } + return &result +} + +func (s *ExecutionStore) parseLearningEntries(v interface{}) []types.LearningEntry { + data, err := s.toJSON(v) + if err != nil { + return nil + } + var entries []types.LearningEntry + if err := json.Unmarshal(data, &entries); err != nil { + return nil + } + return entries +} + +func (s *ExecutionStore) toJSON(v interface{}) ([]byte, error) { + switch data := v.(type) { + case []byte: + return data, nil + case string: + return []byte(data), nil + case map[string]interface{}, []interface{}: + return json.Marshal(data) + default: + return json.Marshal(v) + } +} + +// splitOrderBy parses "column desc" or "column asc" or just "column" +// Returns [column, option] where option defaults to "desc" +func splitOrderBy(orderBy string) [2]string { + parts := [2]string{"", "desc"} + if orderBy == "" { + return parts + } + + // Split by space + for i, c := range orderBy { + if c == ' ' { + parts[0] = orderBy[:i] + rest := orderBy[i+1:] + if rest == "asc" || rest == "ASC" { + parts[1] = "asc" + } else if rest == "desc" || rest == "DESC" { + parts[1] = "desc" + } + return parts + } + } + + // No space found, just column name + parts[0] = orderBy + return parts +} + +func (s *ExecutionStore) parseTime(v interface{}) *time.Time { + switch t := v.(type) { + case time.Time: + return &t + case *time.Time: + return t + case string: + // Try parsing common time formats + formats := []string{ + time.RFC3339, + time.RFC3339Nano, + "2006-01-02 15:04:05", + "2006-01-02T15:04:05Z", + } + for _, format := range formats { + if parsed, err := time.Parse(format, t); err == nil { + return &parsed + } + } + } + return nil +} + +// FromExecution creates an ExecutionRecord from a runtime Execution +func FromExecution(exec *types.Execution, robotID string) *ExecutionRecord { + record := &ExecutionRecord{ + ExecutionID: exec.ID, + RobotID: robotID, + MemberID: exec.MemberID, + TeamID: exec.TeamID, + JobID: exec.JobID, + TriggerType: exec.TriggerType, + Status: exec.Status, + Phase: exec.Phase, + Error: exec.Error, + Input: exec.Input, + Inspiration: exec.Inspiration, + Goals: exec.Goals, + Tasks: exec.Tasks, + Results: exec.Results, + Delivery: exec.Delivery, + Learning: exec.Learning, + } + + // Convert timestamps + if !exec.StartTime.IsZero() { + record.StartTime = &exec.StartTime + } + if exec.EndTime != nil { + record.EndTime = exec.EndTime + } + + // Convert CurrentState + if exec.Current != nil { + record.Current = &CurrentState{ + TaskIndex: exec.Current.TaskIndex, + Progress: exec.Current.Progress, + } + } + + return record +} + +// ToExecution converts an ExecutionRecord to a runtime Execution +func (r *ExecutionRecord) ToExecution() *types.Execution { + exec := &types.Execution{ + ID: r.ExecutionID, + MemberID: r.MemberID, + TeamID: r.TeamID, + JobID: r.JobID, + TriggerType: r.TriggerType, + Status: r.Status, + Phase: r.Phase, + Error: r.Error, + Input: r.Input, + Inspiration: r.Inspiration, + Goals: r.Goals, + Tasks: r.Tasks, + Results: r.Results, + Delivery: r.Delivery, + Learning: r.Learning, + } + + // Convert timestamps + if r.StartTime != nil { + exec.StartTime = *r.StartTime + } + if r.EndTime != nil { + exec.EndTime = r.EndTime + } + + // Convert CurrentState + if r.Current != nil { + exec.Current = &types.CurrentState{ + TaskIndex: r.Current.TaskIndex, + Progress: r.Current.Progress, + } + } + + return exec +} diff --git a/agent/robot/store/execution_test.go b/agent/robot/store/execution_test.go new file mode 100644 index 00000000..1cde0f46 --- /dev/null +++ b/agent/robot/store/execution_test.go @@ -0,0 +1,791 @@ +package store_test + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/yaoapp/gou/model" + "github.com/yaoapp/yao/agent/robot/store" + "github.com/yaoapp/yao/agent/robot/types" + "github.com/yaoapp/yao/agent/testutils" +) + +// TestExecutionStoreSave tests creating and updating execution records +func TestExecutionStoreSave(t *testing.T) { + if testing.Short() { + t.Skip("Skipping integration test") + } + + testutils.Prepare(t) + defer testutils.Clean(t) + + // Clean up any existing test data + cleanupTestExecutions(t) + defer cleanupTestExecutions(t) + + s := store.NewExecutionStore() + ctx := context.Background() + + t.Run("creates_new_execution_record", func(t *testing.T) { + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_save_001", + RobotID: "robot_config_001", + MemberID: "member_test_001", + TeamID: "team_test_001", + JobID: "job_test_001", + TriggerType: types.TriggerClock, + Status: types.ExecPending, + Phase: types.PhaseInspiration, + StartTime: &startTime, + } + + err := s.Save(ctx, record) + require.NoError(t, err) + + // Verify it was created + saved, err := s.Get(ctx, "exec_test_save_001") + require.NoError(t, err) + require.NotNil(t, saved) + + assert.Equal(t, "exec_test_save_001", saved.ExecutionID) + assert.Equal(t, "robot_config_001", saved.RobotID) + assert.Equal(t, "member_test_001", saved.MemberID) + assert.Equal(t, "team_test_001", saved.TeamID) + assert.Equal(t, "job_test_001", saved.JobID) + assert.Equal(t, types.TriggerClock, saved.TriggerType) + assert.Equal(t, types.ExecPending, saved.Status) + assert.Equal(t, types.PhaseInspiration, saved.Phase) + assert.NotNil(t, saved.StartTime) + assert.NotNil(t, saved.CreatedAt) + }) + + t.Run("updates_existing_execution_record", func(t *testing.T) { + // First create a record + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_save_002", + RobotID: "robot_config_002", + MemberID: "member_test_002", + TeamID: "team_test_002", + TriggerType: types.TriggerHuman, + Status: types.ExecPending, + Phase: types.PhaseInspiration, + StartTime: &startTime, + } + + err := s.Save(ctx, record) + require.NoError(t, err) + + // Update the record + record.Status = types.ExecRunning + record.Phase = types.PhaseGoals + record.Goals = &types.Goals{Content: "Test goals content"} + + err = s.Save(ctx, record) + require.NoError(t, err) + + // Verify the update + saved, err := s.Get(ctx, "exec_test_save_002") + require.NoError(t, err) + require.NotNil(t, saved) + + assert.Equal(t, types.ExecRunning, saved.Status) + assert.Equal(t, types.PhaseGoals, saved.Phase) + assert.NotNil(t, saved.Goals) + assert.Equal(t, "Test goals content", saved.Goals.Content) + }) +} + +// TestExecutionStoreGet tests retrieving execution records +func TestExecutionStoreGet(t *testing.T) { + if testing.Short() { + t.Skip("Skipping integration test") + } + + testutils.Prepare(t) + defer testutils.Clean(t) + + cleanupTestExecutions(t) + defer cleanupTestExecutions(t) + + s := store.NewExecutionStore() + ctx := context.Background() + + // Create a test record with all fields populated + setupTestExecution(t, s, ctx) + + t.Run("returns_existing_record", func(t *testing.T) { + record, err := s.Get(ctx, "exec_test_get_001") + require.NoError(t, err) + require.NotNil(t, record) + + assert.Equal(t, "exec_test_get_001", record.ExecutionID) + assert.Equal(t, "robot_config_get", record.RobotID) + assert.Equal(t, "member_test_get", record.MemberID) + assert.Equal(t, "team_test_get", record.TeamID) + assert.Equal(t, types.TriggerClock, record.TriggerType) + assert.Equal(t, types.ExecCompleted, record.Status) + assert.Equal(t, types.PhaseDelivery, record.Phase) + + // Verify phase outputs + assert.NotNil(t, record.Inspiration) + assert.Equal(t, "Test inspiration content", record.Inspiration.Content) + assert.NotNil(t, record.Goals) + assert.Equal(t, "Test goals content", record.Goals.Content) + assert.Len(t, record.Tasks, 2) + assert.Equal(t, "task_001", record.Tasks[0].ID) + assert.Len(t, record.Results, 2) + assert.True(t, record.Results[0].Success) + }) + + t.Run("returns_nil_for_non_existent_record", func(t *testing.T) { + record, err := s.Get(ctx, "exec_non_existent") + require.NoError(t, err) + assert.Nil(t, record) + }) +} + +// TestExecutionStoreList tests listing execution records with filters +func TestExecutionStoreList(t *testing.T) { + if testing.Short() { + t.Skip("Skipping integration test") + } + + testutils.Prepare(t) + defer testutils.Clean(t) + + cleanupTestExecutions(t) + defer cleanupTestExecutions(t) + + s := store.NewExecutionStore() + ctx := context.Background() + + // Create multiple test records + setupTestExecutionsForList(t, s, ctx) + + t.Run("lists_all_records_without_filters", func(t *testing.T) { + records, err := s.List(ctx, nil) + require.NoError(t, err) + assert.GreaterOrEqual(t, len(records), 4) + }) + + t.Run("filters_by_member_id", func(t *testing.T) { + records, err := s.List(ctx, &store.ListOptions{ + MemberID: "member_list_001", + }) + require.NoError(t, err) + assert.Equal(t, 2, len(records)) + for _, r := range records { + assert.Equal(t, "member_list_001", r.MemberID) + } + }) + + t.Run("filters_by_robot_id", func(t *testing.T) { + records, err := s.List(ctx, &store.ListOptions{ + RobotID: "robot_list_001", + }) + require.NoError(t, err) + assert.Equal(t, 2, len(records)) + for _, r := range records { + assert.Equal(t, "robot_list_001", r.RobotID) + } + }) + + t.Run("filters_by_team_id", func(t *testing.T) { + records, err := s.List(ctx, &store.ListOptions{ + TeamID: "team_list_001", + }) + require.NoError(t, err) + assert.Equal(t, 3, len(records)) + for _, r := range records { + assert.Equal(t, "team_list_001", r.TeamID) + } + }) + + t.Run("filters_by_status", func(t *testing.T) { + records, err := s.List(ctx, &store.ListOptions{ + Status: types.ExecCompleted, + }) + require.NoError(t, err) + assert.GreaterOrEqual(t, len(records), 2) + for _, r := range records { + assert.Equal(t, types.ExecCompleted, r.Status) + } + }) + + t.Run("filters_by_trigger_type", func(t *testing.T) { + records, err := s.List(ctx, &store.ListOptions{ + TriggerType: types.TriggerHuman, + }) + require.NoError(t, err) + assert.GreaterOrEqual(t, len(records), 1) + for _, r := range records { + assert.Equal(t, types.TriggerHuman, r.TriggerType) + } + }) + + t.Run("respects_limit", func(t *testing.T) { + records, err := s.List(ctx, &store.ListOptions{ + Limit: 2, + }) + require.NoError(t, err) + assert.Equal(t, 2, len(records)) + }) + + t.Run("combines_multiple_filters", func(t *testing.T) { + records, err := s.List(ctx, &store.ListOptions{ + TeamID: "team_list_001", + Status: types.ExecCompleted, + }) + require.NoError(t, err) + assert.Equal(t, 2, len(records)) + for _, r := range records { + assert.Equal(t, "team_list_001", r.TeamID) + assert.Equal(t, types.ExecCompleted, r.Status) + } + }) +} + +// TestExecutionStoreUpdatePhase tests updating phase and phase data +func TestExecutionStoreUpdatePhase(t *testing.T) { + if testing.Short() { + t.Skip("Skipping integration test") + } + + testutils.Prepare(t) + defer testutils.Clean(t) + + cleanupTestExecutions(t) + defer cleanupTestExecutions(t) + + s := store.NewExecutionStore() + ctx := context.Background() + + // Create a base record + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_phase_001", + RobotID: "robot_phase_001", + MemberID: "member_phase_001", + TeamID: "team_phase_001", + TriggerType: types.TriggerClock, + Status: types.ExecRunning, + Phase: types.PhaseInspiration, + StartTime: &startTime, + } + err := s.Save(ctx, record) + require.NoError(t, err) + + t.Run("updates_inspiration_phase", func(t *testing.T) { + inspiration := &types.InspirationReport{ + Content: "Updated inspiration content", + } + err := s.UpdatePhase(ctx, "exec_test_phase_001", types.PhaseInspiration, inspiration) + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_phase_001") + require.NoError(t, err) + assert.Equal(t, types.PhaseInspiration, saved.Phase) + assert.NotNil(t, saved.Inspiration) + assert.Equal(t, "Updated inspiration content", saved.Inspiration.Content) + }) + + t.Run("updates_goals_phase", func(t *testing.T) { + goals := &types.Goals{ + Content: "Updated goals content", + } + err := s.UpdatePhase(ctx, "exec_test_phase_001", types.PhaseGoals, goals) + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_phase_001") + require.NoError(t, err) + assert.Equal(t, types.PhaseGoals, saved.Phase) + assert.NotNil(t, saved.Goals) + assert.Equal(t, "Updated goals content", saved.Goals.Content) + }) + + t.Run("updates_tasks_phase", func(t *testing.T) { + tasks := []types.Task{ + {ID: "task_phase_001", ExecutorType: types.ExecutorAssistant}, + {ID: "task_phase_002", ExecutorType: types.ExecutorProcess}, + } + err := s.UpdatePhase(ctx, "exec_test_phase_001", types.PhaseTasks, tasks) + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_phase_001") + require.NoError(t, err) + assert.Equal(t, types.PhaseTasks, saved.Phase) + assert.Len(t, saved.Tasks, 2) + assert.Equal(t, "task_phase_001", saved.Tasks[0].ID) + }) + + t.Run("updates_run_phase", func(t *testing.T) { + results := []types.TaskResult{ + {TaskID: "task_phase_001", Success: true, Output: "Result 1"}, + {TaskID: "task_phase_002", Success: false, Error: "Failed"}, + } + err := s.UpdatePhase(ctx, "exec_test_phase_001", types.PhaseRun, results) + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_phase_001") + require.NoError(t, err) + assert.Equal(t, types.PhaseRun, saved.Phase) + assert.Len(t, saved.Results, 2) + assert.True(t, saved.Results[0].Success) + assert.False(t, saved.Results[1].Success) + }) + + t.Run("updates_delivery_phase", func(t *testing.T) { + delivery := &types.DeliveryResult{ + Success: true, + } + err := s.UpdatePhase(ctx, "exec_test_phase_001", types.PhaseDelivery, delivery) + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_phase_001") + require.NoError(t, err) + assert.Equal(t, types.PhaseDelivery, saved.Phase) + assert.NotNil(t, saved.Delivery) + assert.True(t, saved.Delivery.Success) + }) + + t.Run("updates_learning_phase", func(t *testing.T) { + learning := []types.LearningEntry{ + {Type: types.LearnExecution, Content: "Learned something"}, + } + err := s.UpdatePhase(ctx, "exec_test_phase_001", types.PhaseLearning, learning) + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_phase_001") + require.NoError(t, err) + assert.Equal(t, types.PhaseLearning, saved.Phase) + assert.Len(t, saved.Learning, 1) + assert.Equal(t, "Learned something", saved.Learning[0].Content) + }) +} + +// TestExecutionStoreUpdateStatus tests updating execution status +func TestExecutionStoreUpdateStatus(t *testing.T) { + if testing.Short() { + t.Skip("Skipping integration test") + } + + testutils.Prepare(t) + defer testutils.Clean(t) + + cleanupTestExecutions(t) + defer cleanupTestExecutions(t) + + s := store.NewExecutionStore() + ctx := context.Background() + + t.Run("updates_status_to_running", func(t *testing.T) { + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_status_001", + MemberID: "member_status_001", + TeamID: "team_status_001", + TriggerType: types.TriggerClock, + Status: types.ExecPending, + Phase: types.PhaseInspiration, + StartTime: &startTime, + } + err := s.Save(ctx, record) + require.NoError(t, err) + + err = s.UpdateStatus(ctx, "exec_test_status_001", types.ExecRunning, "") + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_status_001") + require.NoError(t, err) + assert.Equal(t, types.ExecRunning, saved.Status) + assert.Nil(t, saved.EndTime) // Should not set end_time for running + }) + + t.Run("updates_status_to_completed_with_end_time", func(t *testing.T) { + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_status_002", + MemberID: "member_status_002", + TeamID: "team_status_002", + TriggerType: types.TriggerHuman, + Status: types.ExecRunning, + Phase: types.PhaseDelivery, + StartTime: &startTime, + } + err := s.Save(ctx, record) + require.NoError(t, err) + + err = s.UpdateStatus(ctx, "exec_test_status_002", types.ExecCompleted, "") + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_status_002") + require.NoError(t, err) + assert.Equal(t, types.ExecCompleted, saved.Status) + assert.NotNil(t, saved.EndTime) // Should set end_time for completed + }) + + t.Run("updates_status_to_failed_with_error", func(t *testing.T) { + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_status_003", + MemberID: "member_status_003", + TeamID: "team_status_003", + TriggerType: types.TriggerEvent, + Status: types.ExecRunning, + Phase: types.PhaseRun, + StartTime: &startTime, + } + err := s.Save(ctx, record) + require.NoError(t, err) + + err = s.UpdateStatus(ctx, "exec_test_status_003", types.ExecFailed, "Task execution failed: timeout") + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_status_003") + require.NoError(t, err) + assert.Equal(t, types.ExecFailed, saved.Status) + assert.Equal(t, "Task execution failed: timeout", saved.Error) + assert.NotNil(t, saved.EndTime) // Should set end_time for failed + }) + + t.Run("updates_status_to_cancelled", func(t *testing.T) { + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_status_004", + MemberID: "member_status_004", + TeamID: "team_status_004", + TriggerType: types.TriggerClock, + Status: types.ExecRunning, + Phase: types.PhaseTasks, + StartTime: &startTime, + } + err := s.Save(ctx, record) + require.NoError(t, err) + + err = s.UpdateStatus(ctx, "exec_test_status_004", types.ExecCancelled, "User cancelled") + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_status_004") + require.NoError(t, err) + assert.Equal(t, types.ExecCancelled, saved.Status) + assert.Equal(t, "User cancelled", saved.Error) + assert.NotNil(t, saved.EndTime) // Should set end_time for cancelled + }) +} + +// TestExecutionStoreUpdateCurrent tests updating current state +func TestExecutionStoreUpdateCurrent(t *testing.T) { + if testing.Short() { + t.Skip("Skipping integration test") + } + + testutils.Prepare(t) + defer testutils.Clean(t) + + cleanupTestExecutions(t) + defer cleanupTestExecutions(t) + + s := store.NewExecutionStore() + ctx := context.Background() + + // Create a base record + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_current_001", + MemberID: "member_current_001", + TeamID: "team_current_001", + TriggerType: types.TriggerClock, + Status: types.ExecRunning, + Phase: types.PhaseRun, + StartTime: &startTime, + } + err := s.Save(ctx, record) + require.NoError(t, err) + + t.Run("updates_current_state", func(t *testing.T) { + current := &store.CurrentState{ + TaskIndex: 2, + Progress: "3/5 tasks completed", + } + err := s.UpdateCurrent(ctx, "exec_test_current_001", current) + require.NoError(t, err) + + saved, err := s.Get(ctx, "exec_test_current_001") + require.NoError(t, err) + assert.NotNil(t, saved.Current) + assert.Equal(t, 2, saved.Current.TaskIndex) + assert.Equal(t, "3/5 tasks completed", saved.Current.Progress) + }) +} + +// TestExecutionStoreDelete tests deleting execution records +func TestExecutionStoreDelete(t *testing.T) { + if testing.Short() { + t.Skip("Skipping integration test") + } + + testutils.Prepare(t) + defer testutils.Clean(t) + + cleanupTestExecutions(t) + defer cleanupTestExecutions(t) + + s := store.NewExecutionStore() + ctx := context.Background() + + t.Run("deletes_existing_record", func(t *testing.T) { + // Create a record + startTime := time.Now() + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_delete_001", + MemberID: "member_delete_001", + TeamID: "team_delete_001", + TriggerType: types.TriggerClock, + Status: types.ExecCompleted, + Phase: types.PhaseDelivery, + StartTime: &startTime, + } + err := s.Save(ctx, record) + require.NoError(t, err) + + // Verify it exists + saved, err := s.Get(ctx, "exec_test_delete_001") + require.NoError(t, err) + require.NotNil(t, saved) + + // Delete it + err = s.Delete(ctx, "exec_test_delete_001") + require.NoError(t, err) + + // Verify it's gone + saved, err = s.Get(ctx, "exec_test_delete_001") + require.NoError(t, err) + assert.Nil(t, saved) + }) + + t.Run("no_error_for_non_existent_record", func(t *testing.T) { + err := s.Delete(ctx, "exec_non_existent") + assert.NoError(t, err) + }) +} + +// TestExecutionRecordConversion tests conversion between ExecutionRecord and Execution +func TestExecutionRecordConversion(t *testing.T) { + if testing.Short() { + t.Skip("Skipping integration test") + } + + testutils.Prepare(t) + defer testutils.Clean(t) + + t.Run("converts_from_execution", func(t *testing.T) { + now := time.Now() + endTime := now.Add(time.Hour) + exec := &types.Execution{ + ID: "exec_convert_001", + MemberID: "member_convert_001", + TeamID: "team_convert_001", + JobID: "job_convert_001", + TriggerType: types.TriggerHuman, + Status: types.ExecCompleted, + Phase: types.PhaseDelivery, + StartTime: now, + EndTime: &endTime, + Error: "", + Inspiration: &types.InspirationReport{Content: "Test inspiration"}, + Goals: &types.Goals{Content: "Test goals"}, + Tasks: []types.Task{ + {ID: "task_001", ExecutorType: types.ExecutorAssistant}, + }, + Results: []types.TaskResult{ + {TaskID: "task_001", Success: true}, + }, + Current: &types.CurrentState{ + TaskIndex: 1, + Progress: "1/1 tasks", + }, + } + + record := store.FromExecution(exec, "robot_convert_001") + + assert.Equal(t, "exec_convert_001", record.ExecutionID) + assert.Equal(t, "robot_convert_001", record.RobotID) + assert.Equal(t, "member_convert_001", record.MemberID) + assert.Equal(t, "team_convert_001", record.TeamID) + assert.Equal(t, "job_convert_001", record.JobID) + assert.Equal(t, types.TriggerHuman, record.TriggerType) + assert.Equal(t, types.ExecCompleted, record.Status) + assert.Equal(t, types.PhaseDelivery, record.Phase) + assert.NotNil(t, record.StartTime) + assert.NotNil(t, record.EndTime) + assert.NotNil(t, record.Inspiration) + assert.NotNil(t, record.Goals) + assert.Len(t, record.Tasks, 1) + assert.Len(t, record.Results, 1) + assert.NotNil(t, record.Current) + assert.Equal(t, 1, record.Current.TaskIndex) + }) + + t.Run("converts_to_execution", func(t *testing.T) { + now := time.Now() + endTime := now.Add(time.Hour) + record := &store.ExecutionRecord{ + ExecutionID: "exec_convert_002", + RobotID: "robot_convert_002", + MemberID: "member_convert_002", + TeamID: "team_convert_002", + JobID: "job_convert_002", + TriggerType: types.TriggerClock, + Status: types.ExecRunning, + Phase: types.PhaseRun, + StartTime: &now, + EndTime: &endTime, + Inspiration: &types.InspirationReport{Content: "Test inspiration"}, + Goals: &types.Goals{Content: "Test goals"}, + Tasks: []types.Task{ + {ID: "task_002", ExecutorType: types.ExecutorProcess}, + }, + Results: []types.TaskResult{ + {TaskID: "task_002", Success: false, Error: "Failed"}, + }, + Current: &store.CurrentState{ + TaskIndex: 0, + Progress: "0/1 tasks", + }, + } + + exec := record.ToExecution() + + assert.Equal(t, "exec_convert_002", exec.ID) + assert.Equal(t, "member_convert_002", exec.MemberID) + assert.Equal(t, "team_convert_002", exec.TeamID) + assert.Equal(t, "job_convert_002", exec.JobID) + assert.Equal(t, types.TriggerClock, exec.TriggerType) + assert.Equal(t, types.ExecRunning, exec.Status) + assert.Equal(t, types.PhaseRun, exec.Phase) + assert.NotNil(t, exec.Inspiration) + assert.NotNil(t, exec.Goals) + assert.Len(t, exec.Tasks, 1) + assert.Len(t, exec.Results, 1) + assert.NotNil(t, exec.Current) + assert.Equal(t, 0, exec.Current.TaskIndex) + }) +} + +// Helper functions + +func cleanupTestExecutions(t *testing.T) { + mod := model.Select("__yao.agent.execution") + if mod == nil { + return + } + + // Delete all test execution records + _, err := mod.DeleteWhere(model.QueryParam{ + Wheres: []model.QueryWhere{ + {Column: "execution_id", OP: "like", Value: "exec_test_%"}, + }, + }) + if err != nil { + t.Logf("Warning: failed to cleanup test executions: %v", err) + } +} + +func setupTestExecution(t *testing.T, s *store.ExecutionStore, ctx context.Context) { + startTime := time.Now().Add(-time.Hour) + endTime := time.Now() + + record := &store.ExecutionRecord{ + ExecutionID: "exec_test_get_001", + RobotID: "robot_config_get", + MemberID: "member_test_get", + TeamID: "team_test_get", + JobID: "job_test_get", + TriggerType: types.TriggerClock, + Status: types.ExecCompleted, + Phase: types.PhaseDelivery, + StartTime: &startTime, + EndTime: &endTime, + Inspiration: &types.InspirationReport{ + Content: "Test inspiration content", + }, + Goals: &types.Goals{ + Content: "Test goals content", + }, + Tasks: []types.Task{ + {ID: "task_001", ExecutorType: types.ExecutorAssistant, Status: types.TaskCompleted}, + {ID: "task_002", ExecutorType: types.ExecutorProcess, Status: types.TaskCompleted}, + }, + Results: []types.TaskResult{ + {TaskID: "task_001", Success: true, Output: "Result 1"}, + {TaskID: "task_002", Success: true, Output: "Result 2"}, + }, + Delivery: &types.DeliveryResult{ + Success: true, + }, + Learning: []types.LearningEntry{ + {Type: types.LearnExecution, Content: "Test learning"}, + }, + } + + err := s.Save(ctx, record) + require.NoError(t, err) +} + +func setupTestExecutionsForList(t *testing.T, s *store.ExecutionStore, ctx context.Context) { + startTime := time.Now() + + records := []*store.ExecutionRecord{ + { + ExecutionID: "exec_test_list_001", + RobotID: "robot_list_001", + MemberID: "member_list_001", + TeamID: "team_list_001", + TriggerType: types.TriggerClock, + Status: types.ExecCompleted, + Phase: types.PhaseDelivery, + StartTime: &startTime, + }, + { + ExecutionID: "exec_test_list_002", + RobotID: "robot_list_001", + MemberID: "member_list_001", + TeamID: "team_list_001", + TriggerType: types.TriggerClock, + Status: types.ExecCompleted, + Phase: types.PhaseDelivery, + StartTime: &startTime, + }, + { + ExecutionID: "exec_test_list_003", + RobotID: "robot_list_002", + MemberID: "member_list_002", + TeamID: "team_list_001", + TriggerType: types.TriggerHuman, + Status: types.ExecRunning, + Phase: types.PhaseRun, + StartTime: &startTime, + }, + { + ExecutionID: "exec_test_list_004", + RobotID: "robot_list_002", + MemberID: "member_list_002", + TeamID: "team_list_002", + TriggerType: types.TriggerEvent, + Status: types.ExecFailed, + Phase: types.PhaseRun, + StartTime: &startTime, + Error: "Test error", + }, + } + + for _, record := range records { + err := s.Save(ctx, record) + require.NoError(t, err) + } +} diff --git a/data/bindata.go b/data/bindata.go index 966a0782..05698283 100644 --- a/data/bindata.go +++ b/data/bindata.go @@ -131,6 +131,7 @@ // .tmp/data/yao/langs/zh-hk/logins/user.login.yml // .tmp/data/yao/models/agent/assistant.mod.yao // .tmp/data/yao/models/agent/chat.mod.yao +// .tmp/data/yao/models/agent/execution.mod.yao // .tmp/data/yao/models/agent/message.mod.yao // .tmp/data/yao/models/agent/resume.mod.yao // .tmp/data/yao/models/agent/search.mod.yao @@ -343,7 +344,7 @@ func cuiSetupIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "cui/setup/index.html", size: 10, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "cui/setup/index.html", size: 10, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -363,7 +364,7 @@ func cuiV09IndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "cui/v0.9/index.html", size: 13, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "cui/v0.9/index.html", size: 13, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -383,7 +384,7 @@ func cuiV10IndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "cui/v1.0/index.html", size: 49, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "cui/v1.0/index.html", size: 49, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -403,7 +404,7 @@ func cuiV10Layouts__indexAsyncJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "cui/v1.0/layouts__index.async.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "cui/v1.0/layouts__index.async.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -423,7 +424,7 @@ func cuiV10UmiJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "cui/v1.0/umi.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "cui/v1.0/umi.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -443,7 +444,7 @@ func initEnv() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.env", size: 219, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.env", size: 219, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -463,7 +464,7 @@ func initVscodeSettingsJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/settings.json", size: 4666, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/settings.json", size: 4666, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -483,7 +484,7 @@ func initVscodeTypesRuntimeConsoleDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/console.d.ts", size: 221, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/console.d.ts", size: 221, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -503,7 +504,7 @@ func initVscodeTypesRuntimeExceptionDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/exception.d.ts", size: 738, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/exception.d.ts", size: 738, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -523,7 +524,7 @@ func initVscodeTypesRuntimeFsDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/fs.d.ts", size: 8554, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/fs.d.ts", size: 8554, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -543,7 +544,7 @@ func initVscodeTypesRuntimeGlobalDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/global.d.ts", size: 1759, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/global.d.ts", size: 1759, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -563,7 +564,7 @@ func initVscodeTypesRuntimeHttpDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/http.d.ts", size: 6179, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/http.d.ts", size: 6179, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -583,7 +584,7 @@ func initVscodeTypesRuntimeIoDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/io.d.ts", size: 587, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/io.d.ts", size: 587, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -603,7 +604,7 @@ func initVscodeTypesRuntimeLogDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/log.d.ts", size: 1692, mode: os.FileMode(493), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/log.d.ts", size: 1692, mode: os.FileMode(493), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -623,7 +624,7 @@ func initVscodeTypesRuntimeNeoDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/neo.d.ts", size: 3750, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/neo.d.ts", size: 3750, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -643,7 +644,7 @@ func initVscodeTypesRuntimeProcessFsDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/process/fs.d.ts", size: 11133, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/process/fs.d.ts", size: 11133, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -663,7 +664,7 @@ func initVscodeTypesRuntimeProcessHttpDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/process/http.d.ts", size: 5653, mode: os.FileMode(493), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/process/http.d.ts", size: 5653, mode: os.FileMode(493), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -683,7 +684,7 @@ func initVscodeTypesRuntimeProcessModelDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/process/model.d.ts", size: 6656, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/process/model.d.ts", size: 6656, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -703,7 +704,7 @@ func initVscodeTypesRuntimeProcessDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/process.d.ts", size: 23165, mode: os.FileMode(493), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/process.d.ts", size: 23165, mode: os.FileMode(493), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -723,7 +724,7 @@ func initVscodeTypesRuntimeQueryDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/query.d.ts", size: 6124, mode: os.FileMode(493), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/query.d.ts", size: 6124, mode: os.FileMode(493), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -743,7 +744,7 @@ func initVscodeTypesRuntimeStoreDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/store.d.ts", size: 2251, mode: os.FileMode(493), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/store.d.ts", size: 2251, mode: os.FileMode(493), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -763,7 +764,7 @@ func initVscodeTypesRuntimeSuiDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/sui.d.ts", size: 1713, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/sui.d.ts", size: 1713, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -783,7 +784,7 @@ func initVscodeTypesRuntimeTimeDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime/time.d.ts", size: 711, mode: os.FileMode(493), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/time.d.ts", size: 711, mode: os.FileMode(493), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -803,7 +804,7 @@ func initVscodeTypesRuntimeDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/runtime.d.ts", size: 424, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime.d.ts", size: 424, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -823,7 +824,7 @@ func initVscodeTypesSuiDTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/types/sui.d.ts", size: 8931, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/.vscode/types/sui.d.ts", size: 8931, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -843,7 +844,7 @@ func initAppYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/app.yao", size: 3115, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/app.yao", size: 3115, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -863,7 +864,7 @@ func initDataReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/README.md", size: 41, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/README.md", size: 41, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -883,7 +884,7 @@ func initDataTemplatesDefault__assetsReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/__assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -903,7 +904,7 @@ func initDataTemplatesDefault__assetsImagesIconsAppPng() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/__assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -923,7 +924,7 @@ func initDataTemplatesDefault__assetsImagesLogosLogo_colorSvg() (*asset, error) return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -943,7 +944,7 @@ func initDataTemplatesDefault__assetsImagesLogosWordmarkSvg() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -963,7 +964,7 @@ func initDataTemplatesDefault__dataJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/__data.json", size: 30, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__data.json", size: 30, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -983,7 +984,7 @@ func initDataTemplatesDefault__documentHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/__document.html", size: 492, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__document.html", size: 492, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1003,7 +1004,7 @@ func initDataTemplatesDefaultIndexIndexCss() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/index/index.css", size: 2896, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/index/index.css", size: 2896, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1023,7 +1024,7 @@ func initDataTemplatesDefaultIndexIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/index/index.html", size: 2361, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/index/index.html", size: 2361, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1043,7 +1044,7 @@ func initDataTemplatesDefaultIndexIndexJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/templates/default/index/index.json", size: 31, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/data/templates/default/index/index.json", size: 31, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1063,7 +1064,7 @@ func initDbReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/db/README.md", size: 84, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/db/README.md", size: 84, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1083,7 +1084,7 @@ func initFlowsMenuFlowYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/flows/menu.flow.yao", size: 813, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/flows/menu.flow.yao", size: 813, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1103,7 +1104,7 @@ func initFormsAccountFormYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/forms/account.form.yao", size: 1194, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/forms/account.form.yao", size: 1194, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1123,7 +1124,7 @@ func initIconsAppIcns() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/icons/app.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/icons/app.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1143,7 +1144,7 @@ func initIconsAppIco() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/icons/app.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/icons/app.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1163,7 +1164,7 @@ func initIconsAppPng() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1183,7 +1184,7 @@ func initLoginsAdminLoginYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/logins/admin.login.yao", size: 302, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/logins/admin.login.yao", size: 302, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1203,7 +1204,7 @@ func initLogsReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/logs/README.md", size: 28, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/logs/README.md", size: 28, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1223,7 +1224,7 @@ func initModelsAdminUserModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/models/admin/user.mod.yao", size: 6416, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/models/admin/user.mod.yao", size: 6416, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1243,7 +1244,7 @@ func initModelsTestsPetModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/models/tests/pet.mod.yao", size: 525, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/models/tests/pet.mod.yao", size: 525, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1263,7 +1264,7 @@ func initNeoNeoYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/neo/neo.yml", size: 724, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/neo/neo.yml", size: 724, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1283,7 +1284,7 @@ func initPublicReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/README.md", size: 108, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/README.md", size: 108, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1303,7 +1304,7 @@ func initPublicAssetsReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1323,7 +1324,7 @@ func initPublicAssetsImagesIconsAppPng() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1343,7 +1344,7 @@ func initPublicAssetsImagesLogosLogo_colorSvg() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1363,7 +1364,7 @@ func initPublicAssetsImagesLogosWordmarkSvg() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1383,7 +1384,7 @@ func initPublicAssetsLibsuiMinJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/assets/libsui.min.js", size: 12569, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/assets/libsui.min.js", size: 12569, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1403,7 +1404,7 @@ func initPublicAssetsLibsuiMinJsMap() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/assets/libsui.min.js.map", size: 38553, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/assets/libsui.min.js.map", size: 38553, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1423,7 +1424,7 @@ func initPublicIndexCfg() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/index.cfg", size: 85, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/index.cfg", size: 85, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1443,7 +1444,7 @@ func initPublicIndexSui() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/index.sui", size: 5682, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/public/index.sui", size: 5682, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1463,7 +1464,7 @@ func initScriptsAccountTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/scripts/account.ts", size: 2521, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/scripts/account.ts", size: 2521, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1483,7 +1484,7 @@ func initScriptsAiNeoTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/scripts/ai/neo.ts", size: 375, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/scripts/ai/neo.ts", size: 375, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1503,7 +1504,7 @@ func initScriptsTestsTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/scripts/tests.ts", size: 1044, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/scripts/tests.ts", size: 1044, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1523,7 +1524,7 @@ func initScriptsUtilsTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/scripts/utils.ts", size: 1230, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/scripts/utils.ts", size: 1230, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1543,7 +1544,7 @@ func initSuisWebSuiYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/suis/web.sui.yao", size: 675, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/suis/web.sui.yao", size: 675, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1563,7 +1564,7 @@ func initTablesAccountTabYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/tables/account.tab.yao", size: 5597, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/tables/account.tab.yao", size: 5597, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1583,7 +1584,7 @@ func initTsconfigJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/tsconfig.json", size: 178, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "init/tsconfig.json", size: 178, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1603,7 +1604,7 @@ func libsuiIndexTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "libsui/index.ts", size: 13047, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "libsui/index.ts", size: 13047, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1623,7 +1624,7 @@ func libsuiOpenapiTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "libsui/openapi.ts", size: 22959, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "libsui/openapi.ts", size: 22959, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1643,7 +1644,7 @@ func libsuiUtilsTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "libsui/utils.ts", size: 5959, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "libsui/utils.ts", size: 5959, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1663,7 +1664,7 @@ func libsuiYaoTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "libsui/yao.ts", size: 4338, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "libsui/yao.ts", size: 4338, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1683,7 +1684,7 @@ func publicIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "public/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "public/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1703,7 +1704,7 @@ func uiIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "ui/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "ui/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1723,7 +1724,7 @@ func yaoAssistantsEntityPackageYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/entity/package.yao", size: 212, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/entity/package.yao", size: 212, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1743,7 +1744,7 @@ func yaoAssistantsEntityPromptsYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/entity/prompts.yml", size: 930, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/entity/prompts.yml", size: 930, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1763,7 +1764,7 @@ func yaoAssistantsKeywordPackageYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/keyword/package.yao", size: 200, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/keyword/package.yao", size: 200, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1783,7 +1784,7 @@ func yaoAssistantsKeywordPromptsYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/keyword/prompts.yml", size: 990, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/keyword/prompts.yml", size: 990, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1803,7 +1804,7 @@ func yaoAssistantsKeywordSrcIndexTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/keyword/src/index.ts", size: 4104, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/keyword/src/index.ts", size: 4104, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1823,7 +1824,7 @@ func yaoAssistantsNeedsearchPackageYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/needsearch/package.yao", size: 207, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/needsearch/package.yao", size: 207, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1843,7 +1844,7 @@ func yaoAssistantsNeedsearchPromptsYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/needsearch/prompts.yml", size: 3092, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/needsearch/prompts.yml", size: 3092, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1863,7 +1864,7 @@ func yaoAssistantsNeedsearchSrcIndexTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/needsearch/src/index.ts", size: 2767, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/needsearch/src/index.ts", size: 2767, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1883,7 +1884,7 @@ func yaoAssistantsPromptPackageYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/prompt/package.yao", size: 186, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/prompt/package.yao", size: 186, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1903,7 +1904,7 @@ func yaoAssistantsPromptPromptsYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/prompt/prompts.yml", size: 621, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/prompt/prompts.yml", size: 621, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1923,7 +1924,7 @@ func yaoAssistantsQuerydslPackageYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/querydsl/package.yao", size: 196, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/querydsl/package.yao", size: 196, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1943,7 +1944,7 @@ func yaoAssistantsQuerydslPromptsAggregationYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/aggregation.yml", size: 6982, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/aggregation.yml", size: 6982, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1963,7 +1964,7 @@ func yaoAssistantsQuerydslPromptsComplexYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/complex.yml", size: 7352, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/complex.yml", size: 7352, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1983,7 +1984,7 @@ func yaoAssistantsQuerydslPromptsFilterYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/filter.yml", size: 7087, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/filter.yml", size: 7087, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2003,7 +2004,7 @@ func yaoAssistantsQuerydslPromptsJoinYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/join.yml", size: 8167, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/join.yml", size: 8167, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2023,7 +2024,7 @@ func yaoAssistantsQuerydslPromptsYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/querydsl/prompts.yml", size: 5836, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/querydsl/prompts.yml", size: 5836, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2043,7 +2044,7 @@ func yaoAssistantsQuerydslSrcIndexTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/querydsl/src/index.ts", size: 1873, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/querydsl/src/index.ts", size: 1873, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2063,7 +2064,7 @@ func yaoAssistantsTitlePackageYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/title/package.yao", size: 178, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/title/package.yao", size: 178, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2083,7 +2084,7 @@ func yaoAssistantsTitlePromptsYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/assistants/title/prompts.yml", size: 958, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/assistants/title/prompts.yml", size: 958, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2103,7 +2104,7 @@ func yaoDataIcons404Png() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/icons/404.png", size: 9342, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/icons/404.png", size: 9342, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2123,7 +2124,7 @@ func yaoDataIconsIconIcns() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/icons/icon.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/icons/icon.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2143,7 +2144,7 @@ func yaoDataIconsIconIco() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/icons/icon.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/icons/icon.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2163,7 +2164,7 @@ func yaoDataIconsIconPng() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/icons/icon.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/icons/icon.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2183,7 +2184,7 @@ func yaoDataIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/index.html", size: 282, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/index.html", size: 282, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2203,7 +2204,7 @@ func yaoDataKbProvidersChunkingSemanticEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/en.json", size: 5543, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/en.json", size: 5543, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2223,7 +2224,7 @@ func yaoDataKbProvidersChunkingSemanticZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/zh-cn.json", size: 5446, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/zh-cn.json", size: 5446, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2243,7 +2244,7 @@ func yaoDataKbProvidersChunkingStructuredEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/en.json", size: 2423, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/en.json", size: 2423, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2263,7 +2264,7 @@ func yaoDataKbProvidersChunkingStructuredZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/zh-cn.json", size: 2321, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/zh-cn.json", size: 2321, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2283,7 +2284,7 @@ func yaoDataKbProvidersConverterMcpEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/en.json", size: 4235, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/en.json", size: 4235, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2303,7 +2304,7 @@ func yaoDataKbProvidersConverterMcpZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/zh-cn.json", size: 4060, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/zh-cn.json", size: 4060, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2323,7 +2324,7 @@ func yaoDataKbProvidersConverterOcrEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/en.json", size: 6631, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/en.json", size: 6631, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2343,7 +2344,7 @@ func yaoDataKbProvidersConverterOcrZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/zh-cn.json", size: 6501, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/zh-cn.json", size: 6501, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2363,7 +2364,7 @@ func yaoDataKbProvidersConverterOfficeEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/en.json", size: 5476, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/en.json", size: 5476, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2383,7 +2384,7 @@ func yaoDataKbProvidersConverterOfficeZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/zh-cn.json", size: 5356, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/zh-cn.json", size: 5356, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2403,7 +2404,7 @@ func yaoDataKbProvidersConverterUtf8EnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/en.json", size: 292, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/en.json", size: 292, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2423,7 +2424,7 @@ func yaoDataKbProvidersConverterUtf8ZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/zh-cn.json", size: 281, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/zh-cn.json", size: 281, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2443,7 +2444,7 @@ func yaoDataKbProvidersConverterVideoEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/en.json", size: 6411, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/en.json", size: 6411, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2463,7 +2464,7 @@ func yaoDataKbProvidersConverterVideoZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/zh-cn.json", size: 6297, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/zh-cn.json", size: 6297, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2483,7 +2484,7 @@ func yaoDataKbProvidersConverterVisionEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/en.json", size: 4085, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/en.json", size: 4085, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2503,7 +2504,7 @@ func yaoDataKbProvidersConverterVisionZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/zh-cn.json", size: 3949, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/zh-cn.json", size: 3949, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2523,7 +2524,7 @@ func yaoDataKbProvidersConverterWhisperEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/en.json", size: 4449, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/en.json", size: 4449, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2543,7 +2544,7 @@ func yaoDataKbProvidersConverterWhisperZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/zh-cn.json", size: 4312, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/zh-cn.json", size: 4312, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2563,7 +2564,7 @@ func yaoDataKbProvidersEmbeddingFastembedEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/en.json", size: 6865, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/en.json", size: 6865, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2583,7 +2584,7 @@ func yaoDataKbProvidersEmbeddingFastembedZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/zh-cn.json", size: 6685, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/zh-cn.json", size: 6685, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2603,7 +2604,7 @@ func yaoDataKbProvidersEmbeddingOpenaiEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/en.json", size: 5636, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/en.json", size: 5636, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2623,7 +2624,7 @@ func yaoDataKbProvidersEmbeddingOpenaiZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/zh-cn.json", size: 5463, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/zh-cn.json", size: 5463, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2643,7 +2644,7 @@ func yaoDataKbProvidersExtractionOpenaiEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/en.json", size: 9110, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/en.json", size: 9110, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2663,7 +2664,7 @@ func yaoDataKbProvidersExtractionOpenaiZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/zh-cn.json", size: 8827, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/zh-cn.json", size: 8827, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2683,7 +2684,7 @@ func yaoDataKbProvidersFetcherHttpEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/en.json", size: 5885, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/en.json", size: 5885, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2703,7 +2704,7 @@ func yaoDataKbProvidersFetcherHttpZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/zh-cn.json", size: 5925, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/zh-cn.json", size: 5925, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2723,7 +2724,7 @@ func yaoDataKbProvidersFetcherMcpEnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/en.json", size: 6819, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/en.json", size: 6819, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2743,7 +2744,7 @@ func yaoDataKbProvidersFetcherMcpZhCnJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/zh-cn.json", size: 6611, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/zh-cn.json", size: 6611, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2763,7 +2764,7 @@ func yaoFieldsModelTransJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/fields/model.trans.json", size: 14938, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/fields/model.trans.json", size: 14938, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2783,7 +2784,7 @@ func yaoLangsEnUsJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/langs/en-US.json", size: 66, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/langs/en-US.json", size: 66, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2803,7 +2804,7 @@ func yaoLangsZhCnGlobalYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/langs/zh-cn/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/langs/zh-cn/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2823,7 +2824,7 @@ func yaoLangsZhCnLoginsAdminLoginYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/langs/zh-cn/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/langs/zh-cn/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2843,7 +2844,7 @@ func yaoLangsZhCnLoginsUserLoginYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/langs/zh-cn/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/langs/zh-cn/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2863,7 +2864,7 @@ func yaoLangsZhHkGlobalYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/langs/zh-hk/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/langs/zh-hk/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2883,7 +2884,7 @@ func yaoLangsZhHkLoginsAdminLoginYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/langs/zh-hk/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/langs/zh-hk/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2903,7 +2904,7 @@ func yaoLangsZhHkLoginsUserLoginYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/langs/zh-hk/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/langs/zh-hk/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2923,7 +2924,7 @@ func yaoModelsAgentAssistantModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/assistant.mod.yao", size: 6945, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/agent/assistant.mod.yao", size: 6945, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2943,7 +2944,27 @@ func yaoModelsAgentChatModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/chat.mod.yao", size: 3093, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/agent/chat.mod.yao", size: 3093, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _yaoModelsAgentExecutionModYao = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x58\x41\x6f\xdb\x38\x13\xbd\xe7\x57\x0c\x74\x4a\x81\xb4\xe8\xf7\x6d\xbb\x40\x72\x5b\x6c\x83\xdd\x2c\xba\x68\x90\xcd\x9e\x82\xc0\xa0\xa5\x91\xcc\x84\x22\xd5\xe1\xb0\x89\x10\xe4\xbf\x2f\x48\xca\x32\x65\xcb\xae\xec\x24\x97\x44\x1e\x0e\x87\xef\xbd\xa1\x86\x1c\x3d\x1d\x01\x64\x5a\xd4\x98\x9d\x41\x76\xfe\x88\xb9\x63\x69\x74\x76\xe2\xcd\x4a\xcc\x51\x79\xfb\x95\x99\x1b\x86\xb5\xd1\x02\x6d\x4e\xb2\x09\x86\xde\x07\x97\x3e\xb0\x90\x96\x0d\xb5\x50\x1a\x02\x26\x91\xdf\x4b\x5d\xc1\xe5\xc7\xf7\x97\x9f\xa1\x59\x08\x8b\x60\x1c\x37\x8e\x2d\x08\x5d\x80\x65\xc1\xce\xc6\xb8\x2c\x2a\x9b\x9d\xc1\x4d\x26\x2a\xd4\x9c\x9d\x40\x46\x3e\xb4\x7f\xb0\xad\x65\xac\xb3\xdb\xe0\x37\x77\x52\xb1\xf4\x6b\x33\x39\x0c\x26\x42\x51\x18\xad\xda\xec\x0c\x4a\xa1\x6c\x34\x5a\x43\x9c\x9d\xc1\xe9\xe9\xe9\x69\x17\x7f\xae\x3c\xdb\xa7\x15\xef\xb0\xd2\x0c\x57\xfc\x20\xcb\x4d\x5d\xfb\xe5\x77\x30\x8b\x81\xe0\x39\x44\xcd\x8d\x72\xb5\x0e\xc0\x8f\x00\x00\x9e\xc2\xdf\x44\x5b\x59\x04\x7a\xc1\xc6\x6d\x13\x6c\x17\x5f\x56\xb6\x5e\xec\xd4\x98\xa0\xf8\xcd\xb1\x79\x2f\x75\x4e\xe8\x2d\xd0\x90\xac\x05\xb5\x70\x8f\x6d\x16\xbc\x9f\x4f\xc6\xd7\xed\x71\xcf\xc6\x10\x58\x26\xa9\xab\x11\x14\x7d\xb2\x61\x0b\x9e\x7f\xb5\xfc\xee\x30\x91\x45\x16\xa8\x59\x96\x12\x29\x09\x87\xba\xe2\x45\x76\x06\xbf\x7e\xea\x6d\xda\x29\xd5\xa5\xa0\x4f\x52\x18\x70\x21\x62\x92\xcf\x60\x95\xba\xc0\xc7\xce\xb8\x93\x68\xd8\x25\xfb\x91\x8c\x99\xdd\x42\x30\x0e\xe6\x46\x97\xb2\x72\x24\x3a\x2d\xe0\xb8\x24\x53\x43\x5c\x2c\x0e\xbe\x9b\xcc\xf7\x30\x62\x35\xd6\x73\xa4\xfd\x98\xfd\x1d\xe6\xec\xa6\x56\x2f\x7d\xe0\xd8\x59\xa4\x2e\x81\xdc\x42\x60\x38\x9b\xb5\xc2\x7c\x88\x3e\xd3\x19\x0e\x33\x3a\x99\x22\xa3\xa8\xf7\x23\x78\x8d\xa2\xde\x46\xaf\x1b\x03\x5e\x60\x4c\x14\xcc\x51\x19\x5d\x59\x60\xf3\xd6\x4c\xee\xcc\x7c\x3f\x22\x7f\x99\xf9\x36\x1e\x5f\xa5\xbe\xc7\x02\xee\xcc\xfc\x43\xf4\x0a\xc5\xb4\x36\x5a\xb2\x59\x8b\xf6\x16\xfb\x8e\x49\x56\x15\xd2\x2c\x50\xd8\x20\x84\xda\xd5\x63\x79\x89\x93\xe0\x7a\x30\x29\x21\xf5\xa7\x79\x00\x5e\x48\x9b\x54\x8e\x07\x61\xa1\x5b\x0c\x13\xe9\xcc\xf2\x6c\xb9\xc9\x72\x65\xf2\x7b\x5f\x96\x17\xae\x16\xa1\x3e\xe3\x0f\x1f\xef\xf6\x15\x33\x97\x9c\x41\x53\x88\xfe\xb3\xe6\x9e\x50\x5c\xd5\xce\xf5\x98\x09\xa5\x06\x75\x11\x72\x08\x19\x39\xad\xbb\xc7\xdc\xd4\x8d\x42\xf6\x32\x40\x56\x0a\xa9\xe2\x53\x2e\x74\x8e\xca\xff\x58\x31\x2e\xb0\x14\x4e\x85\x05\xfb\x58\xaf\xa7\x46\x38\xa3\x27\x8b\x71\x39\xf4\x4e\xb4\xf8\xdd\x11\xf9\xf3\x6a\x95\xed\xb5\xc8\x89\x24\x52\xdb\x46\xc6\x4a\xeb\x49\x57\x46\x28\xeb\x1f\x58\xd8\x7b\xdb\x09\xe5\xff\x15\xa8\xe4\x0f\xa4\xd6\x3f\x2b\x14\x14\xc4\x1b\x15\x66\x10\xf1\xf5\xc4\xc9\x23\xa9\x4d\x79\xee\x6c\xba\x50\x2f\xcf\x52\x04\xbf\x67\x26\xc9\xa4\xab\xb0\x75\x10\x8e\x3d\xf7\x59\x00\x76\x02\x0d\x99\x8a\xd0\xda\x77\xa3\x5c\x7e\x8a\x1a\x89\x0c\x6d\x62\x66\x7c\xe4\xb1\x0b\xc0\xd0\x3b\xdd\xde\x7e\x04\x6a\xb4\x56\x54\x08\xb2\x4c\x72\xbb\xdc\xb1\x87\xc0\x93\xba\x71\xd3\x25\xbd\x18\x7a\x27\xf0\xbe\x91\xac\xa4\x16\x6a\x59\x52\x20\x04\x86\xe3\xae\x32\x85\x89\x07\x2a\x38\xba\x9d\x7e\x0a\x74\x64\x4e\x02\xf7\xf2\x63\x77\x13\x86\xe3\xc4\xf5\x0a\x1b\x43\x87\xc2\xec\x5e\x9c\x89\x00\xff\x18\x7a\xa7\xd0\xfe\xd7\x43\x0b\x4e\x07\xc2\xe9\x5e\xdf\x89\x70\xae\x87\xde\x29\x9c\xff\xf7\x70\x6e\x6e\xbd\xdb\x81\x78\x08\xad\x53\x3c\x1d\xd1\xd5\xba\x7f\x8a\xe9\x97\x35\x4c\xd1\xf9\x40\x64\xab\xc2\x36\x11\xda\x97\x8d\x09\x29\xb6\x4f\x3d\xb6\xa5\xdf\x8b\xd0\xf5\xa5\x76\x2a\xba\xaf\x1b\x13\x52\x74\x9f\x13\xe5\x96\x9e\xe7\x9a\xa9\x3d\x10\x9e\x65\x41\x3c\x63\x59\x8f\x1c\x5b\xde\x6a\x59\xd4\xcd\xf8\x41\x4e\x0c\xd7\x83\x79\xdb\x0e\x73\x62\x18\x09\xf5\xe2\x9b\x16\xea\xe2\x00\xe0\xe7\xba\x98\x02\x1b\x75\xf1\x32\xd0\x47\x00\xb7\x5d\x7b\xad\x42\x71\xf2\x5d\x6e\xe4\xd0\xf5\x26\xfd\xef\x04\xf9\x42\xd8\x6f\x3a\xc1\x56\x9b\x22\xc2\x4e\x1b\x8b\xd5\xb0\xef\x63\xc7\x7b\x9d\xd2\x10\xca\x4a\x0f\x47\x7b\x64\xb1\xfb\x0e\xa0\x71\x67\xf7\xfd\x38\x5b\xeb\xf2\x67\x5d\xb4\xf5\x3b\x5a\xd2\xc9\xa7\x70\xfa\x0b\xe2\xed\x46\x92\xa2\x64\x63\x59\xb8\xf0\x23\xf1\xd6\x1e\x9b\xad\xd5\x51\xf9\xdd\x21\x49\xb4\xf0\x20\x79\xd1\xdd\x13\xa1\x94\x8a\x91\x76\xf7\xf3\x63\x4c\x42\xfb\xb4\x8b\x47\xdf\x5f\xbd\x90\x85\x8f\xf3\x56\x1c\xba\x6e\x23\xbc\x65\x5b\x58\x0c\x1a\x92\xc1\x1b\x7f\x20\x9d\xee\x86\xe0\xe7\x80\xd0\x42\xb5\x56\xda\xfd\xa1\xc7\x8f\x01\x3b\x80\xaf\x3e\x4d\xbc\x02\x68\x1a\xff\x1c\x95\xad\xbd\xac\xfd\xbd\xfa\x29\xa9\x22\x76\xf9\xb6\x43\x66\x4d\xc9\xb3\x02\x7d\xb3\x61\xfb\x9b\xb0\x6f\x25\xa8\x96\xd6\xc6\xa9\xde\x15\x9e\x8f\x9e\x8f\xfe\x0b\x00\x00\xff\xff\xc0\xdd\x8a\x54\x26\x14\x00\x00") + +func yaoModelsAgentExecutionModYaoBytes() ([]byte, error) { + return bindataRead( + _yaoModelsAgentExecutionModYao, + "yao/models/agent/execution.mod.yao", + ) +} + +func yaoModelsAgentExecutionModYao() (*asset, error) { + bytes, err := yaoModelsAgentExecutionModYaoBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "yao/models/agent/execution.mod.yao", size: 5158, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2963,7 +2984,7 @@ func yaoModelsAgentMessageModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/message.mod.yao", size: 3712, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/agent/message.mod.yao", size: 3712, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2983,7 +3004,7 @@ func yaoModelsAgentResumeModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/resume.mod.yao", size: 3896, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/agent/resume.mod.yao", size: 3896, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3003,7 +3024,7 @@ func yaoModelsAgentSearchModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/search.mod.yao", size: 3103, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/agent/search.mod.yao", size: 3103, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3023,7 +3044,7 @@ func yaoModelsAttachmentModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/attachment.mod.yao", size: 4687, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/attachment.mod.yao", size: 4687, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3043,7 +3064,7 @@ func yaoModelsAuditModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/audit.mod.yao", size: 5588, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/audit.mod.yao", size: 5588, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3063,7 +3084,7 @@ func yaoModelsConfigModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/config.mod.yao", size: 1649, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/config.mod.yao", size: 1649, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3083,7 +3104,7 @@ func yaoModelsDslModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/dsl.mod.yao", size: 3826, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/dsl.mod.yao", size: 3826, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3103,7 +3124,7 @@ func yaoModelsInvitationModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/invitation.mod.yao", size: 6693, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/invitation.mod.yao", size: 6693, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3123,7 +3144,7 @@ func yaoModelsJobCategoryModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/job/category.mod.yao", size: 2041, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/job/category.mod.yao", size: 2041, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3143,7 +3164,7 @@ func yaoModelsJobExecutionModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/job/execution.mod.yao", size: 7201, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/job/execution.mod.yao", size: 7201, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3163,7 +3184,7 @@ func yaoModelsJobJobModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/job/job.mod.yao", size: 6429, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/job/job.mod.yao", size: 6429, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3183,7 +3204,7 @@ func yaoModelsJobLogModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/job/log.mod.yao", size: 4711, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/job/log.mod.yao", size: 4711, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3203,7 +3224,7 @@ func yaoModelsKbCollectionModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/kb/collection.mod.yao", size: 5390, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/kb/collection.mod.yao", size: 5390, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3223,7 +3244,7 @@ func yaoModelsKbDocumentModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/kb/document.mod.yao", size: 9906, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/kb/document.mod.yao", size: 9906, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3243,7 +3264,7 @@ func yaoModelsMemberModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/member.mod.yao", size: 14798, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/member.mod.yao", size: 14798, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3263,7 +3284,7 @@ func yaoModelsRoleModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/role.mod.yao", size: 6434, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/role.mod.yao", size: 6434, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3283,7 +3304,7 @@ func yaoModelsTeamModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/team.mod.yao", size: 15823, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/team.mod.yao", size: 15823, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3303,7 +3324,7 @@ func yaoModelsUserOauth_accountModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/user/oauth_account.mod.yao", size: 6928, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/user/oauth_account.mod.yao", size: 6928, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3323,7 +3344,7 @@ func yaoModelsUserTypeModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/user/type.mod.yao", size: 7502, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/user/type.mod.yao", size: 7502, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3343,7 +3364,7 @@ func yaoModelsUserModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/user.mod.yao", size: 12335, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/models/user.mod.yao", size: 12335, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3363,7 +3384,7 @@ func yaoReleaseAppYaz() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/release/app.yaz", size: 181682, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/release/app.yaz", size: 181682, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3383,7 +3404,7 @@ func yaoStoresAgentCacheLruYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/agent/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/agent/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3403,7 +3424,7 @@ func yaoStoresAgentMemoryChatXunYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/agent/memory/chat.xun.yao", size: 497, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/agent/memory/chat.xun.yao", size: 497, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3423,7 +3444,7 @@ func yaoStoresAgentMemoryContextXunYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/agent/memory/context.xun.yao", size: 507, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/agent/memory/context.xun.yao", size: 507, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3443,7 +3464,7 @@ func yaoStoresAgentMemoryTeamXunYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/agent/memory/team.xun.yao", size: 483, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/agent/memory/team.xun.yao", size: 483, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3463,7 +3484,7 @@ func yaoStoresAgentMemoryUserXunYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/agent/memory/user.xun.yao", size: 489, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/agent/memory/user.xun.yao", size: 489, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3483,7 +3504,7 @@ func yaoStoresCacheLruYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/cache.lru.yao", size: 285, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/cache.lru.yao", size: 285, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3503,7 +3524,7 @@ func yaoStoresKbCacheLruYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/kb/cache.lru.yao", size: 304, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/kb/cache.lru.yao", size: 304, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3523,7 +3544,7 @@ func yaoStoresKbStoreXunYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/kb/store.xun.yao", size: 373, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/kb/store.xun.yao", size: 373, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3543,7 +3564,7 @@ func yaoStoresOauthCacheLruYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/oauth/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/oauth/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3563,7 +3584,7 @@ func yaoStoresOauthClientXunYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/oauth/client.xun.yao", size: 377, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/oauth/client.xun.yao", size: 377, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3583,7 +3604,7 @@ func yaoStoresOauthStoreXunYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/oauth/store.xun.yao", size: 401, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/oauth/store.xun.yao", size: 401, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3603,7 +3624,7 @@ func yaoStoresStoreXunYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/store.xun.yao", size: 369, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/stores/store.xun.yao", size: 369, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3623,7 +3644,7 @@ func yaoUploadersAttachmentLocalYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/uploaders/attachment.local.yao", size: 1163, mode: os.FileMode(420), modTime: time.Unix(1768464477, 0)} + info := bindataFileInfo{name: "yao/uploaders/attachment.local.yao", size: 1163, mode: os.FileMode(420), modTime: time.Unix(1768724959, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3811,6 +3832,7 @@ var _bindata = map[string]func() (*asset, error){ "yao/langs/zh-hk/logins/user.login.yml": yaoLangsZhHkLoginsUserLoginYml, "yao/models/agent/assistant.mod.yao": yaoModelsAgentAssistantModYao, "yao/models/agent/chat.mod.yao": yaoModelsAgentChatModYao, + "yao/models/agent/execution.mod.yao": yaoModelsAgentExecutionModYao, "yao/models/agent/message.mod.yao": yaoModelsAgentMessageModYao, "yao/models/agent/resume.mod.yao": yaoModelsAgentResumeModYao, "yao/models/agent/search.mod.yao": yaoModelsAgentSearchModYao, @@ -4182,6 +4204,7 @@ var _bintree = &bintree{nil, map[string]*bintree{ "agent": {nil, map[string]*bintree{ "assistant.mod.yao": {yaoModelsAgentAssistantModYao, map[string]*bintree{}}, "chat.mod.yao": {yaoModelsAgentChatModYao, map[string]*bintree{}}, + "execution.mod.yao": {yaoModelsAgentExecutionModYao, map[string]*bintree{}}, "message.mod.yao": {yaoModelsAgentMessageModYao, map[string]*bintree{}}, "resume.mod.yao": {yaoModelsAgentResumeModYao, map[string]*bintree{}}, "search.mod.yao": {yaoModelsAgentSearchModYao, map[string]*bintree{}}, diff --git a/model/model.go b/model/model.go index 45f88fa1..3ae6d65b 100644 --- a/model/model.go +++ b/model/model.go @@ -22,6 +22,7 @@ import ( var systemModels = map[string]string{ "__yao.agent.assistant": "yao/models/agent/assistant.mod.yao", "__yao.agent.chat": "yao/models/agent/chat.mod.yao", + "__yao.agent.execution": "yao/models/agent/execution.mod.yao", "__yao.agent.message": "yao/models/agent/message.mod.yao", "__yao.agent.resume": "yao/models/agent/resume.mod.yao", "__yao.agent.search": "yao/models/agent/search.mod.yao", diff --git a/test/utils.go b/test/utils.go index b7d06d5b..11bf75f5 100644 --- a/test/utils.go +++ b/test/utils.go @@ -197,6 +197,7 @@ var testServer *http.Server = nil var testSystemModels = map[string]string{ "__yao.agent.assistant": "yao/models/agent/assistant.mod.yao", "__yao.agent.chat": "yao/models/agent/chat.mod.yao", + "__yao.agent.execution": "yao/models/agent/execution.mod.yao", "__yao.agent.message": "yao/models/agent/message.mod.yao", "__yao.agent.resume": "yao/models/agent/resume.mod.yao", "__yao.agent.search": "yao/models/agent/search.mod.yao", diff --git a/yao/models/agent/execution.mod.yao b/yao/models/agent/execution.mod.yao new file mode 100644 index 00000000..77bed523 --- /dev/null +++ b/yao/models/agent/execution.mod.yao @@ -0,0 +1,207 @@ +{ + "name": "Execution", + "label": "Robot Execution", + "description": "Robot execution history for tracking P0-P5 phase outputs and status", + "tags": ["agent", "robot", "system"], + "builtin": true, + "readonly": false, + "sort": 9999, + "table": { "name": "agent_execution", "comment": "Robot execution history table" }, + "columns": [ + { + "name": "id", + "type": "ID", + "label": "ID", + "comment": "Auto-increment primary key" + }, + { + "name": "execution_id", + "type": "string", + "label": "Execution ID", + "comment": "Unique execution identifier", + "length": 64, + "nullable": false, + "unique": true, + "index": true + }, + { + "name": "robot_id", + "type": "string", + "label": "Robot ID", + "comment": "Robot configuration ID (from robot_config)", + "length": 64, + "nullable": true, + "index": true + }, + { + "name": "member_id", + "type": "string", + "label": "Member ID", + "comment": "Robot member ID (user identity from __yao.member)", + "length": 64, + "nullable": false, + "index": true + }, + { + "name": "team_id", + "type": "string", + "label": "Team ID", + "comment": "Team ID the robot belongs to", + "length": 64, + "nullable": false, + "index": true + }, + { + "name": "job_id", + "type": "string", + "label": "Job ID", + "comment": "Linked job.Job ID for monitoring", + "length": 64, + "nullable": true, + "index": true + }, + { + "name": "trigger_type", + "type": "enum", + "label": "Trigger Type", + "comment": "How this execution was triggered", + "option": ["clock", "human", "event"], + "nullable": false, + "index": true + }, + { + "name": "status", + "type": "enum", + "label": "Status", + "comment": "Execution status", + "option": ["pending", "running", "completed", "failed", "cancelled"], + "default": "pending", + "nullable": false, + "index": true + }, + { + "name": "phase", + "type": "enum", + "label": "Phase", + "comment": "Current execution phase", + "option": ["inspiration", "goals", "tasks", "run", "delivery", "learning"], + "default": "inspiration", + "nullable": false, + "index": true + }, + { + "name": "current", + "type": "json", + "label": "Current State", + "comment": "Current executing state (task_index, progress)", + "nullable": true + }, + { + "name": "error", + "type": "text", + "label": "Error", + "comment": "Error message if execution failed", + "nullable": true + }, + { + "name": "input", + "type": "json", + "label": "Input", + "comment": "Original trigger input (TriggerInput)", + "nullable": true + }, + { + "name": "inspiration", + "type": "json", + "label": "Inspiration", + "comment": "P0 output (InspirationReport)", + "nullable": true + }, + { + "name": "goals", + "type": "json", + "label": "Goals", + "comment": "P1 output (Goals)", + "nullable": true + }, + { + "name": "tasks", + "type": "json", + "label": "Tasks", + "comment": "P2 output ([]Task)", + "nullable": true + }, + { + "name": "results", + "type": "json", + "label": "Results", + "comment": "P3 output ([]TaskResult)", + "nullable": true + }, + { + "name": "delivery", + "type": "json", + "label": "Delivery", + "comment": "P4 output (DeliveryResult)", + "nullable": true + }, + { + "name": "learning", + "type": "json", + "label": "Learning", + "comment": "P5 output ([]LearningEntry)", + "nullable": true + }, + { + "name": "start_time", + "type": "timestamp", + "label": "Start Time", + "comment": "Execution start timestamp", + "nullable": true, + "index": true + }, + { + "name": "end_time", + "type": "timestamp", + "label": "End Time", + "comment": "Execution end timestamp", + "nullable": true, + "index": true + } + ], + "relations": { + "member": { + "type": "hasOne", + "model": "__yao.member", + "key": "member_id", + "foreign": "member_id" + } + }, + "indexes": [ + { + "name": "idx_agent_execution_member_status", + "columns": ["member_id", "status"], + "type": "index", + "comment": "Index for member execution queries with status filter" + }, + { + "name": "idx_agent_execution_team_status", + "columns": ["team_id", "status"], + "type": "index", + "comment": "Index for team execution queries with status filter" + }, + { + "name": "idx_agent_execution_trigger_start", + "columns": ["trigger_type", "start_time"], + "type": "index", + "comment": "Index for trigger type analysis" + }, + { + "name": "idx_agent_execution_robot_start", + "columns": ["robot_id", "start_time"], + "type": "index", + "comment": "Index for robot execution history" + } + ], + "option": { "timestamps": true, "soft_deletes": false, "permission": true } +}