From f2e0312e61d071452fee4c0852c6fc220310d0a0 Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 9 Dec 2025 10:54:58 +0800 Subject: [PATCH] Implement chat management functionalities in Xun store - Added CreateChat, GetChat, UpdateChat, and DeleteChat methods to manage chat sessions effectively. - Implemented validation for required fields and handling of nullable fields during chat creation and updates. - Enhanced chat retrieval with pagination and filtering options, including time-based grouping. - Introduced helper functions for converting database rows to Chat structs and grouping chats by time. - Updated message and resume models to support soft deletes, improving data management and integrity. --- agent/store/xun/chat.go | 435 ++++++++++++++- agent/store/xun/chat_test.go | 881 +++++++++++++++++++++++++++++++ agent/store/xun/message.go | 1 - agent/store/xun/resume.go | 1 - data/bindata.go | 288 +++++----- yao/models/agent/message.mod.yao | 3 +- yao/models/agent/resume.mod.yao | 2 +- 7 files changed, 1451 insertions(+), 160 deletions(-) create mode 100644 agent/store/xun/chat_test.go diff --git a/agent/store/xun/chat.go b/agent/store/xun/chat.go index 1e5db7b3..4a8545f0 100644 --- a/agent/store/xun/chat.go +++ b/agent/store/xun/chat.go @@ -1,6 +1,13 @@ package xun import ( + "fmt" + "math" + "time" + + "github.com/google/uuid" + jsoniter "github.com/json-iterator/go" + "github.com/yaoapp/xun/dbal/query" "github.com/yaoapp/yao/agent/store/types" ) @@ -10,30 +17,436 @@ import ( // CreateChat creates a new chat session func (store *Xun) CreateChat(chat *types.Chat) error { - // TODO: implement - return nil + if chat == nil { + return fmt.Errorf("chat cannot be nil") + } + + // Validate required fields + if chat.AssistantID == "" { + return fmt.Errorf("assistant_id is required") + } + + // Generate chat_id if not provided + if chat.ChatID == "" { + chat.ChatID = uuid.New().String() + } + + // Check if chat already exists + exists, err := store.newQueryChat(). + Where("chat_id", chat.ChatID). + Exists() + if err != nil { + return err + } + if exists { + return fmt.Errorf("chat %s already exists", chat.ChatID) + } + + // Set defaults + if chat.Mode == "" { + chat.Mode = "chat" + } + if chat.Status == "" { + chat.Status = "active" + } + if chat.Share == "" { + chat.Share = "private" + } + + // Prepare data + data := map[string]interface{}{ + "chat_id": chat.ChatID, + "assistant_id": chat.AssistantID, + "mode": chat.Mode, + "status": chat.Status, + "public": chat.Public, + "share": chat.Share, + "sort": chat.Sort, + "created_at": time.Now(), + "updated_at": time.Now(), + } + + // Handle nullable fields + if chat.Title != "" { + data["title"] = chat.Title + } + if chat.LastMessageAt != nil { + data["last_message_at"] = *chat.LastMessageAt + } + if chat.Metadata != nil { + metadataJSON, err := jsoniter.MarshalToString(chat.Metadata) + if err != nil { + return fmt.Errorf("failed to marshal metadata: %w", err) + } + data["metadata"] = metadataJSON + } + + // Insert + return store.newQueryChat().Insert(data) } // GetChat retrieves a single chat by ID func (store *Xun) GetChat(chatID string) (*types.Chat, error) { - // TODO: implement - return nil, nil + if chatID == "" { + return nil, fmt.Errorf("chat_id is required") + } + + row, err := store.newQueryChat(). + Where("chat_id", chatID). + WhereNull("deleted_at"). + First() + if err != nil { + return nil, err + } + + if row == nil { + return nil, fmt.Errorf("chat %s not found", chatID) + } + + data := row.ToMap() + if len(data) == 0 || data["chat_id"] == nil { + return nil, fmt.Errorf("chat %s not found", chatID) + } + + return store.rowToChat(data) } // UpdateChat updates chat fields func (store *Xun) UpdateChat(chatID string, updates map[string]interface{}) error { - // TODO: implement - return nil + if chatID == "" { + return fmt.Errorf("chat_id is required") + } + if len(updates) == 0 { + return fmt.Errorf("no fields to update") + } + + // Check if chat exists + exists, err := store.newQueryChat(). + Where("chat_id", chatID). + WhereNull("deleted_at"). + Exists() + if err != nil { + return err + } + if !exists { + return fmt.Errorf("chat %s not found", chatID) + } + + // Prepare update data + data := make(map[string]interface{}) + + // Process each update field + for key, value := range updates { + // Skip system fields + if key == "chat_id" || key == "created_at" { + continue + } + + // Handle metadata specially + if key == "metadata" { + if value != nil { + metadataJSON, err := jsoniter.MarshalToString(value) + if err != nil { + return fmt.Errorf("failed to marshal metadata: %w", err) + } + data["metadata"] = metadataJSON + } else { + data["metadata"] = nil + } + continue + } + + data[key] = value + } + + // Always update updated_at + data["updated_at"] = time.Now() + + if len(data) == 0 { + return fmt.Errorf("no valid fields to update") + } + + _, err = store.newQueryChat(). + Where("chat_id", chatID). + Update(data) + + return err } -// DeleteChat deletes a chat and its associated messages +// DeleteChat deletes a chat and its associated messages (soft delete) func (store *Xun) DeleteChat(chatID string) error { - // TODO: implement - return nil + if chatID == "" { + return fmt.Errorf("chat_id is required") + } + + // Check if chat exists + exists, err := store.newQueryChat(). + Where("chat_id", chatID). + WhereNull("deleted_at"). + Exists() + if err != nil { + return err + } + if !exists { + return fmt.Errorf("chat %s not found", chatID) + } + + // Soft delete the chat + _, err = store.newQueryChat(). + Where("chat_id", chatID). + Update(map[string]interface{}{ + "deleted_at": time.Now(), + "updated_at": time.Now(), + }) + + return err } // ListChats retrieves a paginated list of chats with optional grouping func (store *Xun) ListChats(filter types.ChatFilter) (*types.ChatList, error) { - // TODO: implement - return nil, nil + // Set defaults + if filter.Page <= 0 { + filter.Page = 1 + } + if filter.PageSize <= 0 { + filter.PageSize = 20 + } + if filter.OrderBy == "" { + filter.OrderBy = "last_message_at" + } + if filter.Order == "" { + filter.Order = "desc" + } + if filter.TimeField == "" { + filter.TimeField = "last_message_at" + } + + // Build base query + qb := store.newQueryChat().WhereNull("deleted_at") + + // Apply filters + if filter.AssistantID != "" { + qb.Where("assistant_id", filter.AssistantID) + } + if filter.Status != "" { + qb.Where("status", filter.Status) + } + if filter.Keywords != "" { + qb.Where("title", "like", fmt.Sprintf("%%%s%%", filter.Keywords)) + } + + // Apply time range filter + if filter.StartTime != nil { + qb.Where(filter.TimeField, ">=", *filter.StartTime) + } + if filter.EndTime != nil { + qb.Where(filter.TimeField, "<=", *filter.EndTime) + } + + // Apply custom query filter (for permission filtering) + if filter.QueryFilter != nil { + qb.Where(filter.QueryFilter) + } + + // Get total count + total, err := qb.Clone().Count() + if err != nil { + return nil, err + } + + // Calculate pagination + pageCount := int(math.Ceil(float64(total) / float64(filter.PageSize))) + if pageCount < 1 { + pageCount = 1 + } + offset := (filter.Page - 1) * filter.PageSize + + // Get paginated results + rows, err := qb.OrderBy(filter.OrderBy, filter.Order). + Offset(offset). + Limit(filter.PageSize). + Get() + if err != nil { + return nil, err + } + + // Convert rows to Chat objects + chats := make([]*types.Chat, 0, len(rows)) + for _, row := range rows { + data := row.ToMap() + if data == nil || data["chat_id"] == nil { + continue + } + + chat, err := store.rowToChat(data) + if err != nil { + continue + } + chats = append(chats, chat) + } + + result := &types.ChatList{ + Data: chats, + Page: filter.Page, + PageSize: filter.PageSize, + PageCount: pageCount, + Total: int(total), + } + + // Apply time-based grouping if requested + if filter.GroupBy == "time" { + result.Groups = store.groupChatsByTime(chats) + } + + return result, nil +} + +// ============================================================================= +// Helper Functions +// ============================================================================= + +// rowToChat converts a database row to a Chat struct +func (store *Xun) rowToChat(data map[string]interface{}) (*types.Chat, error) { + chat := &types.Chat{ + ChatID: getString(data, "chat_id"), + Title: getString(data, "title"), + AssistantID: getString(data, "assistant_id"), + Mode: getString(data, "mode"), + Status: getString(data, "status"), + Public: getBool(data, "public"), + Share: getString(data, "share"), + Sort: getInt(data, "sort"), + } + + // Handle timestamps + if createdAt := getTime(data, "created_at"); createdAt != nil { + chat.CreatedAt = *createdAt + } + if updatedAt := getTime(data, "updated_at"); updatedAt != nil { + chat.UpdatedAt = *updatedAt + } + if lastMsgAt := getTime(data, "last_message_at"); lastMsgAt != nil { + chat.LastMessageAt = lastMsgAt + } + + // Handle metadata + if metadata := data["metadata"]; metadata != nil { + if metaStr, ok := metadata.(string); ok && metaStr != "" { + var meta map[string]interface{} + if err := jsoniter.UnmarshalFromString(metaStr, &meta); err == nil { + chat.Metadata = meta + } + } else if metaMap, ok := metadata.(map[string]interface{}); ok { + chat.Metadata = metaMap + } + } + + return chat, nil +} + +// groupChatsByTime groups chats by time periods +func (store *Xun) groupChatsByTime(chats []*types.Chat) []*types.ChatGroup { + now := time.Now() + today := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()) + yesterday := today.AddDate(0, 0, -1) + thisWeekStart := today.AddDate(0, 0, -int(today.Weekday())) + thisMonthStart := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location()) + + groups := map[string]*types.ChatGroup{ + "today": {Key: "today", Label: "Today", Chats: []*types.Chat{}}, + "yesterday": {Key: "yesterday", Label: "Yesterday", Chats: []*types.Chat{}}, + "this_week": {Key: "this_week", Label: "This Week", Chats: []*types.Chat{}}, + "this_month": {Key: "this_month", Label: "This Month", Chats: []*types.Chat{}}, + "earlier": {Key: "earlier", Label: "Earlier", Chats: []*types.Chat{}}, + } + + for _, chat := range chats { + // Use last_message_at if available, otherwise created_at + var chatTime time.Time + if chat.LastMessageAt != nil { + chatTime = *chat.LastMessageAt + } else { + chatTime = chat.CreatedAt + } + + chatDate := time.Date(chatTime.Year(), chatTime.Month(), chatTime.Day(), 0, 0, 0, 0, chatTime.Location()) + + switch { + case chatDate.Equal(today) || chatDate.After(today): + groups["today"].Chats = append(groups["today"].Chats, chat) + case chatDate.Equal(yesterday): + groups["yesterday"].Chats = append(groups["yesterday"].Chats, chat) + case chatDate.After(thisWeekStart) || chatDate.Equal(thisWeekStart): + groups["this_week"].Chats = append(groups["this_week"].Chats, chat) + case chatDate.After(thisMonthStart) || chatDate.Equal(thisMonthStart): + groups["this_month"].Chats = append(groups["this_month"].Chats, chat) + default: + groups["earlier"].Chats = append(groups["earlier"].Chats, chat) + } + } + + // Update counts and filter empty groups + result := make([]*types.ChatGroup, 0) + for _, key := range []string{"today", "yesterday", "this_week", "this_month", "earlier"} { + group := groups[key] + group.Count = len(group.Chats) + if group.Count > 0 { + result = append(result, group) + } + } + + return result +} + +// getTime helper function to convert database value to time.Time pointer +func getTime(data map[string]interface{}, key string) *time.Time { + if v := data[key]; v != nil { + switch t := v.(type) { + case time.Time: + return &t + case *time.Time: + return t + case string: + // Try parsing various formats + formats := []string{ + time.RFC3339, + "2006-01-02 15:04:05", + "2006-01-02 15:04:05.999999-07:00", + "2006-01-02T15:04:05Z", + } + for _, format := range formats { + if parsed, err := time.Parse(format, t); err == nil { + return &parsed + } + } + } + } + return nil +} + +// UpdateChatLastMessageAt updates the last_message_at timestamp for a chat +func (store *Xun) UpdateChatLastMessageAt(chatID string, timestamp time.Time) error { + if chatID == "" { + return fmt.Errorf("chat_id is required") + } + + _, err := store.newQueryChat(). + Where("chat_id", chatID). + Update(map[string]interface{}{ + "last_message_at": timestamp, + "updated_at": time.Now(), + }) + + return err +} + +// newQueryChatWithPermission creates a new query builder with permission filtering +func (store *Xun) newQueryChatWithPermission(filter types.ChatFilter) query.Query { + qb := store.newQueryChat().WhereNull("deleted_at") + + if filter.QueryFilter != nil { + qb.Where(filter.QueryFilter) + } + + return qb } diff --git a/agent/store/xun/chat_test.go b/agent/store/xun/chat_test.go new file mode 100644 index 00000000..0a790de7 --- /dev/null +++ b/agent/store/xun/chat_test.go @@ -0,0 +1,881 @@ +package xun_test + +import ( + "fmt" + "testing" + "time" + + "github.com/yaoapp/xun/dbal/query" + "github.com/yaoapp/yao/agent/store/types" + "github.com/yaoapp/yao/agent/store/xun" + "github.com/yaoapp/yao/config" + "github.com/yaoapp/yao/test" +) + +// TestCreateChat tests creating chat sessions +func TestCreateChat(t *testing.T) { + test.Prepare(t, config.Conf) + defer test.Clean() + + store, err := xun.NewXun(types.Setting{ + Connector: "default", + }) + if err != nil { + t.Fatalf("Failed to create store: %v", err) + } + + t.Run("CreateNewChat", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + Title: "Test Chat", + Mode: "chat", + Status: "active", + Share: "private", + } + + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + if chat.ChatID == "" { + t.Error("Expected chat_id to be generated") + } + + t.Logf("Created chat with ID: %s", chat.ChatID) + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("CreateChatWithAllFields", func(t *testing.T) { + now := time.Now() + chat := &types.Chat{ + AssistantID: "test_assistant", + Title: "Full Chat", + Mode: "task", + Status: "active", + Public: true, + Share: "team", + Sort: 100, + LastMessageAt: &now, + Metadata: map[string]interface{}{ + "source": "test", + "tags": []string{"test", "chat"}, + }, + } + + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + // Retrieve and verify + retrieved, err := store.GetChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to retrieve chat: %v", err) + } + + if retrieved.Title != "Full Chat" { + t.Errorf("Expected title 'Full Chat', got '%s'", retrieved.Title) + } + if retrieved.Mode != "task" { + t.Errorf("Expected mode 'task', got '%s'", retrieved.Mode) + } + if !retrieved.Public { + t.Error("Expected public to be true") + } + if retrieved.Share != "team" { + t.Errorf("Expected share 'team', got '%s'", retrieved.Share) + } + if retrieved.Sort != 100 { + t.Errorf("Expected sort 100, got %d", retrieved.Sort) + } + if retrieved.Metadata == nil { + t.Error("Expected metadata to be set") + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("CreateChatWithCustomID", func(t *testing.T) { + customID := fmt.Sprintf("custom_chat_%d", time.Now().UnixNano()) + chat := &types.Chat{ + ChatID: customID, + AssistantID: "test_assistant", + } + + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + if chat.ChatID != customID { + t.Errorf("Expected chat_id '%s', got '%s'", customID, chat.ChatID) + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("CreateDuplicateChatFails", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + } + + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create first chat: %v", err) + } + + // Try to create with same ID + duplicateChat := &types.Chat{ + ChatID: chat.ChatID, + AssistantID: "test_assistant", + } + + err = store.CreateChat(duplicateChat) + if err == nil { + t.Error("Expected error when creating duplicate chat") + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("CreateChatWithoutAssistantIDFails", func(t *testing.T) { + chat := &types.Chat{ + Title: "No Assistant", + } + + err := store.CreateChat(chat) + if err == nil { + t.Error("Expected error when creating chat without assistant_id") + } + }) + + t.Run("CreateNilChatFails", func(t *testing.T) { + err := store.CreateChat(nil) + if err == nil { + t.Error("Expected error when creating nil chat") + } + }) + + t.Run("CreateChatWithDefaults", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + } + + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + // Retrieve and verify defaults + retrieved, err := store.GetChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to retrieve chat: %v", err) + } + + if retrieved.Mode != "chat" { + t.Errorf("Expected default mode 'chat', got '%s'", retrieved.Mode) + } + if retrieved.Status != "active" { + t.Errorf("Expected default status 'active', got '%s'", retrieved.Status) + } + if retrieved.Share != "private" { + t.Errorf("Expected default share 'private', got '%s'", retrieved.Share) + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) +} + +// TestGetChat tests retrieving chat sessions +func TestGetChat(t *testing.T) { + test.Prepare(t, config.Conf) + defer test.Clean() + + store, err := xun.NewXun(types.Setting{ + Connector: "default", + }) + if err != nil { + t.Fatalf("Failed to create store: %v", err) + } + + t.Run("GetExistingChat", func(t *testing.T) { + // Create chat first + chat := &types.Chat{ + AssistantID: "test_assistant", + Title: "Get Test Chat", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + // Get it + retrieved, err := store.GetChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to get chat: %v", err) + } + + if retrieved.ChatID != chat.ChatID { + t.Errorf("Expected chat_id '%s', got '%s'", chat.ChatID, retrieved.ChatID) + } + if retrieved.Title != "Get Test Chat" { + t.Errorf("Expected title 'Get Test Chat', got '%s'", retrieved.Title) + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("GetNonExistentChat", func(t *testing.T) { + _, err := store.GetChat("nonexistent_chat_id") + if err == nil { + t.Error("Expected error when getting non-existent chat") + } + }) + + t.Run("GetChatWithEmptyID", func(t *testing.T) { + _, err := store.GetChat("") + if err == nil { + t.Error("Expected error when getting chat with empty ID") + } + }) + + t.Run("GetDeletedChatFails", func(t *testing.T) { + // Create and delete chat + chat := &types.Chat{ + AssistantID: "test_assistant", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + err = store.DeleteChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to delete chat: %v", err) + } + + // Try to get deleted chat + _, err = store.GetChat(chat.ChatID) + if err == nil { + t.Error("Expected error when getting deleted chat") + } + }) +} + +// TestUpdateChat tests updating chat sessions +func TestUpdateChat(t *testing.T) { + test.Prepare(t, config.Conf) + defer test.Clean() + + store, err := xun.NewXun(types.Setting{ + Connector: "default", + }) + if err != nil { + t.Fatalf("Failed to create store: %v", err) + } + + t.Run("UpdateTitle", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + Title: "Original Title", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + err = store.UpdateChat(chat.ChatID, map[string]interface{}{ + "title": "Updated Title", + }) + if err != nil { + t.Fatalf("Failed to update chat: %v", err) + } + + retrieved, err := store.GetChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to retrieve chat: %v", err) + } + + if retrieved.Title != "Updated Title" { + t.Errorf("Expected title 'Updated Title', got '%s'", retrieved.Title) + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("UpdateMultipleFields", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + Title: "Original", + Status: "active", + Share: "private", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + err = store.UpdateChat(chat.ChatID, map[string]interface{}{ + "title": "Updated", + "status": "archived", + "share": "team", + "public": true, + "sort": 50, + }) + if err != nil { + t.Fatalf("Failed to update chat: %v", err) + } + + retrieved, err := store.GetChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to retrieve chat: %v", err) + } + + if retrieved.Title != "Updated" { + t.Errorf("Expected title 'Updated', got '%s'", retrieved.Title) + } + if retrieved.Status != "archived" { + t.Errorf("Expected status 'archived', got '%s'", retrieved.Status) + } + if retrieved.Share != "team" { + t.Errorf("Expected share 'team', got '%s'", retrieved.Share) + } + if !retrieved.Public { + t.Error("Expected public to be true") + } + if retrieved.Sort != 50 { + t.Errorf("Expected sort 50, got %d", retrieved.Sort) + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("UpdateMetadata", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + err = store.UpdateChat(chat.ChatID, map[string]interface{}{ + "metadata": map[string]interface{}{ + "key1": "value1", + "key2": 123, + }, + }) + if err != nil { + t.Fatalf("Failed to update metadata: %v", err) + } + + retrieved, err := store.GetChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to retrieve chat: %v", err) + } + + if retrieved.Metadata == nil { + t.Fatal("Expected metadata to be set") + } + if retrieved.Metadata["key1"] != "value1" { + t.Errorf("Expected metadata key1 'value1', got '%v'", retrieved.Metadata["key1"]) + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("UpdateNonExistentChatFails", func(t *testing.T) { + err := store.UpdateChat("nonexistent_chat", map[string]interface{}{ + "title": "Test", + }) + if err == nil { + t.Error("Expected error when updating non-existent chat") + } + }) + + t.Run("UpdateWithEmptyIDFails", func(t *testing.T) { + err := store.UpdateChat("", map[string]interface{}{ + "title": "Test", + }) + if err == nil { + t.Error("Expected error when updating with empty ID") + } + }) + + t.Run("UpdateWithEmptyFieldsFails", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + err = store.UpdateChat(chat.ChatID, map[string]interface{}{}) + if err == nil { + t.Error("Expected error when updating with empty fields") + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) + + t.Run("UpdateSkipsSystemFields", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + originalID := chat.ChatID + + // Try to update system fields + err = store.UpdateChat(chat.ChatID, map[string]interface{}{ + "chat_id": "new_id", + "title": "Valid Update", + }) + if err != nil { + t.Fatalf("Failed to update chat: %v", err) + } + + // Verify chat_id unchanged + retrieved, err := store.GetChat(originalID) + if err != nil { + t.Fatalf("Failed to retrieve chat: %v", err) + } + + if retrieved.ChatID != originalID { + t.Errorf("Expected chat_id to remain '%s', got '%s'", originalID, retrieved.ChatID) + } + if retrieved.Title != "Valid Update" { + t.Errorf("Expected title 'Valid Update', got '%s'", retrieved.Title) + } + + // Clean up + _ = store.DeleteChat(chat.ChatID) + }) +} + +// TestDeleteChat tests deleting chat sessions +func TestDeleteChat(t *testing.T) { + test.Prepare(t, config.Conf) + defer test.Clean() + + store, err := xun.NewXun(types.Setting{ + Connector: "default", + }) + if err != nil { + t.Fatalf("Failed to create store: %v", err) + } + + t.Run("DeleteExistingChat", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + err = store.DeleteChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to delete chat: %v", err) + } + + // Verify deleted + _, err = store.GetChat(chat.ChatID) + if err == nil { + t.Error("Expected error when getting deleted chat") + } + }) + + t.Run("DeleteNonExistentChatFails", func(t *testing.T) { + err := store.DeleteChat("nonexistent_chat") + if err == nil { + t.Error("Expected error when deleting non-existent chat") + } + }) + + t.Run("DeleteWithEmptyIDFails", func(t *testing.T) { + err := store.DeleteChat("") + if err == nil { + t.Error("Expected error when deleting with empty ID") + } + }) + + t.Run("DeleteAlreadyDeletedChatFails", func(t *testing.T) { + chat := &types.Chat{ + AssistantID: "test_assistant", + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + + // Delete first time + err = store.DeleteChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to delete chat: %v", err) + } + + // Try to delete again + err = store.DeleteChat(chat.ChatID) + if err == nil { + t.Error("Expected error when deleting already deleted chat") + } + }) +} + +// TestListChats tests listing chat sessions +func TestListChats(t *testing.T) { + test.Prepare(t, config.Conf) + defer test.Clean() + + store, err := xun.NewXun(types.Setting{ + Connector: "default", + }) + if err != nil { + t.Fatalf("Failed to create store: %v", err) + } + + // Create test chats + chatIDs := []string{} + for i := 0; i < 5; i++ { + chat := &types.Chat{ + AssistantID: "test_assistant", + Title: fmt.Sprintf("Chat %d", i), + Status: "active", + } + if i >= 3 { + chat.Status = "archived" + } + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + chatIDs = append(chatIDs, chat.ChatID) + + // Add small delay to ensure different timestamps + time.Sleep(10 * time.Millisecond) + } + + // Clean up at the end + defer func() { + for _, id := range chatIDs { + _ = store.DeleteChat(id) + } + }() + + t.Run("ListAllChats", func(t *testing.T) { + result, err := store.ListChats(types.ChatFilter{ + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats: %v", err) + } + + if len(result.Data) < 5 { + t.Errorf("Expected at least 5 chats, got %d", len(result.Data)) + } + }) + + t.Run("ListChatsByStatus", func(t *testing.T) { + result, err := store.ListChats(types.ChatFilter{ + Status: "active", + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats: %v", err) + } + + for _, chat := range result.Data { + if chat.Status != "active" { + t.Errorf("Expected status 'active', got '%s'", chat.Status) + } + } + }) + + t.Run("ListChatsByAssistant", func(t *testing.T) { + result, err := store.ListChats(types.ChatFilter{ + AssistantID: "test_assistant", + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats: %v", err) + } + + for _, chat := range result.Data { + if chat.AssistantID != "test_assistant" { + t.Errorf("Expected assistant_id 'test_assistant', got '%s'", chat.AssistantID) + } + } + }) + + t.Run("ListChatsByKeywords", func(t *testing.T) { + result, err := store.ListChats(types.ChatFilter{ + Keywords: "Chat 1", + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats: %v", err) + } + + found := false + for _, chat := range result.Data { + if chat.Title == "Chat 1" { + found = true + break + } + } + if !found { + t.Error("Expected to find chat with title 'Chat 1'") + } + }) + + t.Run("ListChatsPagination", func(t *testing.T) { + // First page + result1, err := store.ListChats(types.ChatFilter{ + Page: 1, + PageSize: 2, + }) + if err != nil { + t.Fatalf("Failed to list first page: %v", err) + } + + if len(result1.Data) > 2 { + t.Errorf("Expected max 2 chats, got %d", len(result1.Data)) + } + if result1.Page != 1 { + t.Errorf("Expected page 1, got %d", result1.Page) + } + if result1.PageSize != 2 { + t.Errorf("Expected pagesize 2, got %d", result1.PageSize) + } + + // Second page + if result1.Total > 2 { + result2, err := store.ListChats(types.ChatFilter{ + Page: 2, + PageSize: 2, + }) + if err != nil { + t.Fatalf("Failed to list second page: %v", err) + } + if result2.Page != 2 { + t.Errorf("Expected page 2, got %d", result2.Page) + } + } + }) + + t.Run("ListChatsWithGrouping", func(t *testing.T) { + result, err := store.ListChats(types.ChatFilter{ + GroupBy: "time", + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats with grouping: %v", err) + } + + // Should have groups when GroupBy is "time" + if result.Groups == nil { + t.Error("Expected groups to be set when GroupBy='time'") + } + + // Verify group structure + for _, group := range result.Groups { + if group.Key == "" { + t.Error("Expected group key to be set") + } + if group.Label == "" { + t.Error("Expected group label to be set") + } + if group.Count != len(group.Chats) { + t.Errorf("Expected count %d to match chats length %d", group.Count, len(group.Chats)) + } + } + }) + + t.Run("ListChatsWithTimeRange", func(t *testing.T) { + now := time.Now() + yesterday := now.AddDate(0, 0, -1) + + result, err := store.ListChats(types.ChatFilter{ + StartTime: &yesterday, + EndTime: &now, + TimeField: "created_at", + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats with time range: %v", err) + } + + // Should return chats created within the time range + t.Logf("Found %d chats in time range", len(result.Data)) + }) + + t.Run("ListChatsWithSorting", func(t *testing.T) { + // Ascending order + resultAsc, err := store.ListChats(types.ChatFilter{ + OrderBy: "created_at", + Order: "asc", + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats ascending: %v", err) + } + + // Descending order + resultDesc, err := store.ListChats(types.ChatFilter{ + OrderBy: "created_at", + Order: "desc", + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats descending: %v", err) + } + + // Verify different order + if len(resultAsc.Data) > 1 && len(resultDesc.Data) > 1 { + if resultAsc.Data[0].ChatID == resultDesc.Data[0].ChatID { + // This is fine if there's only one chat, but otherwise order should differ + if len(resultAsc.Data) > 1 { + t.Logf("First chat in asc: %s, first in desc: %s", resultAsc.Data[0].ChatID, resultDesc.Data[0].ChatID) + } + } + } + }) + + t.Run("ListChatsWithQueryFilter", func(t *testing.T) { + result, err := store.ListChats(types.ChatFilter{ + Page: 1, + PageSize: 20, + QueryFilter: func(qb query.Query) { + qb.Where("status", "active") + }, + }) + if err != nil { + t.Fatalf("Failed to list chats with query filter: %v", err) + } + + for _, chat := range result.Data { + if chat.Status != "active" { + t.Errorf("Expected status 'active', got '%s'", chat.Status) + } + } + }) +} + +// TestChatCompleteWorkflow tests a complete chat workflow +func TestChatCompleteWorkflow(t *testing.T) { + test.Prepare(t, config.Conf) + defer test.Clean() + + store, err := xun.NewXun(types.Setting{ + Connector: "default", + }) + if err != nil { + t.Fatalf("Failed to create store: %v", err) + } + + t.Run("CompleteWorkflow", func(t *testing.T) { + // 1. Create chat + chat := &types.Chat{ + AssistantID: "workflow_assistant", + Title: "Workflow Test Chat", + Mode: "chat", + Status: "active", + } + + err := store.CreateChat(chat) + if err != nil { + t.Fatalf("Failed to create chat: %v", err) + } + t.Logf("Created chat: %s", chat.ChatID) + + // 2. Get chat + retrieved, err := store.GetChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to get chat: %v", err) + } + if retrieved.Title != "Workflow Test Chat" { + t.Errorf("Expected title 'Workflow Test Chat', got '%s'", retrieved.Title) + } + + // 3. Update chat + err = store.UpdateChat(chat.ChatID, map[string]interface{}{ + "title": "Updated Workflow Chat", + "status": "archived", + }) + if err != nil { + t.Fatalf("Failed to update chat: %v", err) + } + + // 4. Verify update + updated, err := store.GetChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to get updated chat: %v", err) + } + if updated.Title != "Updated Workflow Chat" { + t.Errorf("Expected title 'Updated Workflow Chat', got '%s'", updated.Title) + } + if updated.Status != "archived" { + t.Errorf("Expected status 'archived', got '%s'", updated.Status) + } + + // 5. List chats + result, err := store.ListChats(types.ChatFilter{ + AssistantID: "workflow_assistant", + Page: 1, + PageSize: 20, + }) + if err != nil { + t.Fatalf("Failed to list chats: %v", err) + } + + found := false + for _, c := range result.Data { + if c.ChatID == chat.ChatID { + found = true + break + } + } + if !found { + t.Error("Expected to find chat in list") + } + + // 6. Delete chat + err = store.DeleteChat(chat.ChatID) + if err != nil { + t.Fatalf("Failed to delete chat: %v", err) + } + + // 7. Verify deletion + _, err = store.GetChat(chat.ChatID) + if err == nil { + t.Error("Expected error when getting deleted chat") + } + + t.Log("Complete workflow passed!") + }) +} diff --git a/agent/store/xun/message.go b/agent/store/xun/message.go index 5503cef2..09bfd8fd 100644 --- a/agent/store/xun/message.go +++ b/agent/store/xun/message.go @@ -33,4 +33,3 @@ func (store *Xun) DeleteMessages(chatID string, messageIDs []string) error { // TODO: implement return nil } - diff --git a/agent/store/xun/resume.go b/agent/store/xun/resume.go index c89b9d7e..0f39ef04 100644 --- a/agent/store/xun/resume.go +++ b/agent/store/xun/resume.go @@ -46,4 +46,3 @@ func (store *Xun) DeleteResume(chatID string) error { // TODO: implement return nil } - diff --git a/data/bindata.go b/data/bindata.go index 537c22cf..bdfe3d34 100644 --- a/data/bindata.go +++ b/data/bindata.go @@ -320,7 +320,7 @@ func cuiSetupIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "cui/setup/index.html", size: 10, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "cui/setup/index.html", size: 10, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -340,7 +340,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(1765246552, 0)} + info := bindataFileInfo{name: "cui/v0.9/index.html", size: 13, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -360,7 +360,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(1765246552, 0)} + info := bindataFileInfo{name: "cui/v1.0/index.html", size: 49, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -380,7 +380,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(1765246552, 0)} + info := bindataFileInfo{name: "cui/v1.0/layouts__index.async.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -400,7 +400,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(1765246552, 0)} + info := bindataFileInfo{name: "cui/v1.0/umi.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -420,7 +420,7 @@ func initEnv() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.env", size: 219, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/.env", size: 219, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -440,7 +440,7 @@ func initVscodeSettingsJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/.vscode/settings.json", size: 4666, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/settings.json", size: 4666, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -460,7 +460,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/console.d.ts", size: 221, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -480,7 +480,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/exception.d.ts", size: 738, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -500,7 +500,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/fs.d.ts", size: 8554, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -520,7 +520,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/global.d.ts", size: 1759, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -540,7 +540,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/http.d.ts", size: 6179, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -560,7 +560,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/io.d.ts", size: 587, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -580,7 +580,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/log.d.ts", size: 1692, mode: os.FileMode(493), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -600,7 +600,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/neo.d.ts", size: 3750, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -620,7 +620,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/process/fs.d.ts", size: 11133, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -640,7 +640,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/process/http.d.ts", size: 5653, mode: os.FileMode(493), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -660,7 +660,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/process/model.d.ts", size: 6656, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -680,7 +680,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/process.d.ts", size: 23165, mode: os.FileMode(493), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -700,7 +700,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/query.d.ts", size: 6124, mode: os.FileMode(493), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -720,7 +720,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/store.d.ts", size: 2251, mode: os.FileMode(493), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -740,7 +740,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/sui.d.ts", size: 1713, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -760,7 +760,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime/time.d.ts", size: 711, mode: os.FileMode(493), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -780,7 +780,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/runtime.d.ts", size: 424, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -800,7 +800,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(1765246552, 0)} + info := bindataFileInfo{name: "init/.vscode/types/sui.d.ts", size: 8931, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -820,7 +820,7 @@ func initAppYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/app.yao", size: 3115, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/app.yao", size: 3115, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -840,7 +840,7 @@ func initDataReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/data/README.md", size: 41, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/data/README.md", size: 41, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -860,7 +860,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -880,7 +880,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -900,7 +900,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -920,7 +920,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -940,7 +940,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__data.json", size: 30, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -960,7 +960,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/__document.html", size: 492, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -980,7 +980,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/index/index.css", size: 2896, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1000,7 +1000,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/index/index.html", size: 2361, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1020,7 +1020,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(1765246552, 0)} + info := bindataFileInfo{name: "init/data/templates/default/index/index.json", size: 31, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1040,7 +1040,7 @@ func initDbReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/db/README.md", size: 84, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/db/README.md", size: 84, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1060,7 +1060,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(1765246552, 0)} + info := bindataFileInfo{name: "init/flows/menu.flow.yao", size: 813, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1080,7 +1080,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(1765246552, 0)} + info := bindataFileInfo{name: "init/forms/account.form.yao", size: 1194, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1100,7 +1100,7 @@ func initIconsAppIcns() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/icons/app.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/icons/app.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1120,7 +1120,7 @@ func initIconsAppIco() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/icons/app.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/icons/app.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1140,7 +1140,7 @@ func initIconsAppPng() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1160,7 +1160,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(1765246552, 0)} + info := bindataFileInfo{name: "init/logins/admin.login.yao", size: 302, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1180,7 +1180,7 @@ func initLogsReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/logs/README.md", size: 28, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/logs/README.md", size: 28, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1200,7 +1200,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(1765246552, 0)} + info := bindataFileInfo{name: "init/models/admin/user.mod.yao", size: 6416, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1220,7 +1220,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(1765246552, 0)} + info := bindataFileInfo{name: "init/models/tests/pet.mod.yao", size: 525, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1240,7 +1240,7 @@ func initNeoNeoYml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/neo/neo.yml", size: 724, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/neo/neo.yml", size: 724, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1260,7 +1260,7 @@ func initPublicReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/README.md", size: 108, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/public/README.md", size: 108, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1280,7 +1280,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(1765246552, 0)} + info := bindataFileInfo{name: "init/public/assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1300,7 +1300,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(1765246552, 0)} + info := bindataFileInfo{name: "init/public/assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1320,7 +1320,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(1765246552, 0)} + info := bindataFileInfo{name: "init/public/assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1340,7 +1340,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(1765246552, 0)} + info := bindataFileInfo{name: "init/public/assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1360,7 +1360,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(1765246552, 0)} + info := bindataFileInfo{name: "init/public/assets/libsui.min.js", size: 12569, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1380,7 +1380,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(1765246552, 0)} + info := bindataFileInfo{name: "init/public/assets/libsui.min.js.map", size: 38553, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1400,7 +1400,7 @@ func initPublicIndexCfg() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/index.cfg", size: 85, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/public/index.cfg", size: 85, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1420,7 +1420,7 @@ func initPublicIndexSui() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/public/index.sui", size: 5682, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/public/index.sui", size: 5682, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1440,7 +1440,7 @@ func initScriptsAccountTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/scripts/account.ts", size: 2521, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/scripts/account.ts", size: 2521, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1460,7 +1460,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(1765246552, 0)} + info := bindataFileInfo{name: "init/scripts/ai/neo.ts", size: 375, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1480,7 +1480,7 @@ func initScriptsTestsTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/scripts/tests.ts", size: 1044, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/scripts/tests.ts", size: 1044, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1500,7 +1500,7 @@ func initScriptsUtilsTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/scripts/utils.ts", size: 1230, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/scripts/utils.ts", size: 1230, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1520,7 +1520,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(1765246552, 0)} + info := bindataFileInfo{name: "init/suis/web.sui.yao", size: 675, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1540,7 +1540,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(1765246552, 0)} + info := bindataFileInfo{name: "init/tables/account.tab.yao", size: 5597, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1560,7 +1560,7 @@ func initTsconfigJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init/tsconfig.json", size: 178, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "init/tsconfig.json", size: 178, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1580,7 +1580,7 @@ func libsuiAgentTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "libsui/agent.ts", size: 15267, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "libsui/agent.ts", size: 15267, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1600,7 +1600,7 @@ func libsuiIndexTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "libsui/index.ts", size: 13049, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "libsui/index.ts", size: 13049, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1620,7 +1620,7 @@ func libsuiUtilsTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "libsui/utils.ts", size: 5959, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "libsui/utils.ts", size: 5959, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1640,7 +1640,7 @@ func libsuiYaoTs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "libsui/yao.ts", size: 4338, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "libsui/yao.ts", size: 4338, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1660,7 +1660,7 @@ func publicIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "public/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "public/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1680,7 +1680,7 @@ func uiIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "ui/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "ui/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1700,7 +1700,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/icons/404.png", size: 9342, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1720,7 +1720,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/icons/icon.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1740,7 +1740,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/icons/icon.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1760,7 +1760,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/icons/icon.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1780,7 +1780,7 @@ func yaoDataIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/data/index.html", size: 282, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/index.html", size: 282, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1800,7 +1800,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/en.json", size: 5543, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1820,7 +1820,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/zh-cn.json", size: 5446, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1840,7 +1840,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/en.json", size: 2423, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1860,7 +1860,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/zh-cn.json", size: 2321, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1880,7 +1880,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/en.json", size: 4235, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1900,7 +1900,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/zh-cn.json", size: 4060, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1920,7 +1920,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/en.json", size: 6631, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1940,7 +1940,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/zh-cn.json", size: 6501, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1960,7 +1960,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/en.json", size: 5476, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -1980,7 +1980,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/zh-cn.json", size: 5356, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2000,7 +2000,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/en.json", size: 292, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2020,7 +2020,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/zh-cn.json", size: 281, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2040,7 +2040,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/en.json", size: 6411, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2060,7 +2060,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/zh-cn.json", size: 6297, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2080,7 +2080,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/en.json", size: 4085, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2100,7 +2100,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/zh-cn.json", size: 3949, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2120,7 +2120,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/en.json", size: 4449, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2140,7 +2140,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/zh-cn.json", size: 4312, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2160,7 +2160,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/en.json", size: 6865, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2180,7 +2180,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/zh-cn.json", size: 6685, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2200,7 +2200,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/en.json", size: 5636, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2220,7 +2220,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/zh-cn.json", size: 5463, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2240,7 +2240,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/en.json", size: 9110, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2260,7 +2260,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/zh-cn.json", size: 8827, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2280,7 +2280,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/en.json", size: 5885, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2300,7 +2300,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/zh-cn.json", size: 5925, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2320,7 +2320,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/en.json", size: 6819, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2340,7 +2340,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/zh-cn.json", size: 6611, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2360,7 +2360,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/fields/model.trans.json", size: 14938, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2380,7 +2380,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/langs/en-US.json", size: 66, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2400,7 +2400,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/langs/zh-cn/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2420,7 +2420,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/langs/zh-cn/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2440,7 +2440,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/langs/zh-cn/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2460,7 +2460,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/langs/zh-hk/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2480,7 +2480,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/langs/zh-hk/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2500,7 +2500,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/langs/zh-hk/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2520,7 +2520,7 @@ func yaoModelsAgentAssistantModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/assistant.mod.yao", size: 6758, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/agent/assistant.mod.yao", size: 6758, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2540,12 +2540,12 @@ func yaoModelsAgentChatModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/chat.mod.yao", size: 2854, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/agent/chat.mod.yao", size: 2854, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _yaoModelsAgentMessageModYao = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x56\x4d\x6f\xdb\x38\x10\xbd\xfb\x57\x0c\x78\xf2\x02\x4a\x36\x58\xec\x2e\x60\xdf\xd2\xf6\x92\x43\xd0\xa0\x4d\x4f\x41\x20\xd0\xd2\x58\x66\xc2\x0f\x87\x1c\xa5\x31\x0c\xff\xf7\x82\xb4\x24\x53\x31\x65\x44\x46\x7b\x31\xe0\x99\xd1\xf0\xbd\x99\x79\x43\x6e\x27\x00\x4c\x73\x85\x6c\x0e\xec\x16\x9d\xe3\x15\xb2\xcc\x1b\x25\x5f\xa0\x3c\xb2\x96\xe8\x0a\x2b\xd6\x24\x8c\xf6\xbe\xcf\x2b\x4e\xa0\xf6\x01\x40\x7c\x21\x11\x96\xc6\x82\x23\x63\x85\xae\xa0\x76\x68\x2f\x5e\x85\x13\xde\xd1\x84\xb9\x7d\x22\xe2\x95\x63\x73\x78\x60\xbc\x42\x4d\x2c\x03\xe6\x36\x8e\x50\xb1\xc7\xe0\x5e\xd4\x42\x92\xf0\x67\x90\xad\x31\x98\x2c\xf2\xd2\x68\xb9\x89\x6d\xce\x58\x62\x73\x98\xcd\x66\xb3\x26\xeb\x42\x7a\x2a\xdb\x03\xa9\x90\x3f\x57\x2d\x09\x60\x85\x51\xca\x1f\x39\x07\x76\xed\x7d\x50\x1c\x91\x60\xb0\x0b\xe9\x0a\x23\x6b\xa5\x03\xce\x09\x00\xc0\x36\xfc\x46\x15\x13\x65\x60\x13\x6c\xb4\x59\x07\xdb\xcd\x97\x83\xad\x2b\x62\x6c\x8c\x01\xd4\x64\x2e\x84\x2e\x2c\x7a\x0b\xac\xad\x50\xdc\x6e\xe0\x19\x37\x2c\x44\xef\xb2\xf4\xb9\x0d\xda\x3c\x75\xbe\x23\x5f\xfb\x04\x86\xa6\x91\x30\x80\xe5\x87\x16\x2f\x75\xd7\x26\x10\x25\x6a\x12\x4b\x81\x36\x4a\x85\xba\xa2\x15\x9b\xc3\xff\xff\x76\x36\x5d\x4b\xd9\x54\x7d\xc9\xa5\xc3\xce\x51\x87\x7c\x4d\xb7\x4e\xb2\xf1\x0d\x18\x47\x25\xcc\xdd\x00\x8f\x3b\x6e\xbb\xae\xf6\x7a\x31\x06\xbc\xd0\x25\xbe\x7d\x04\xbb\xc5\x97\x1a\xdd\x48\xf8\xdf\xf6\x1f\x0d\x31\x38\xb8\x83\x9a\x2a\x6b\xea\x75\x3f\xd1\x69\x2a\xad\x3c\x46\x32\x31\x12\x8f\x39\xa0\xae\x55\x8a\x41\x2f\x38\xc2\xde\x0e\x59\x3f\x9b\x69\x37\xc6\x03\xf3\x3b\xc1\xcb\x90\x3b\x27\x1c\x71\x4d\x7b\xc5\xff\xa6\x76\x04\xd8\x1f\x6f\xc4\x7d\x2f\x3c\x41\xc3\x67\x80\x29\xe1\x1b\x65\x20\x14\xaf\x30\x03\x69\x78\x29\x74\x95\x01\x19\x23\xf3\x82\x4b\x99\x81\x45\xb2\x02\x5f\xb9\xcc\x00\xa9\xb8\xfc\x2b\xd1\xaa\xff\xae\x06\x69\x9e\x64\xb4\xb6\x66\xed\x8e\x29\x3d\x39\xa3\x13\x84\xee\xfa\xd1\x09\x46\x3e\x1f\x5a\x12\xe8\x60\x5a\x18\x4d\xa8\x29\x83\xda\x1e\x23\x1f\x85\x72\x21\x4d\xf1\x3c\x4e\x04\x9f\xfc\x27\x43\x12\xd8\x3b\xdb\xc9\x1f\xa3\xe3\xf3\x86\x9f\x56\xfe\x7a\x19\x47\xe0\x3e\x7c\x33\xc4\xa0\xf1\x46\x14\x82\x98\x0b\xa3\x8b\xda\x86\x0d\xe5\xfb\xc0\xbd\x2e\xdc\x1f\x26\xd7\x49\x6d\x1c\xbf\xeb\xf6\xb3\x21\x8a\x71\x00\x4c\x9f\x8c\xd0\x40\x06\x2a\x24\xf0\x27\xff\xcd\x5f\x39\x71\x9b\xd2\xc2\x3f\x57\x49\x31\x9c\xc7\xce\xf9\x6d\xa9\x8b\x84\xec\x85\x26\xac\x7a\xf7\x57\x4b\xed\xfb\xd1\x37\x09\xa5\x18\x5b\xa2\x85\x9f\x82\x56\x42\x87\xeb\xe4\x4c\x6d\x28\x24\x5e\x72\xe2\x1f\x16\xf1\xed\xd1\x07\x71\xd1\xcb\x52\xf8\xa1\xe1\x12\xda\xc4\x30\xed\x56\x51\x2e\xca\x66\x31\xf9\xd3\x4f\x69\xfa\x50\xd7\x09\xc0\x63\xf3\xc2\x92\xcd\x3c\xce\x1b\x16\xe1\x6a\xee\xfe\x45\xc8\x57\xdc\x7d\xd5\x51\xf9\x94\x29\xf7\xd8\xf3\x7c\xc3\xcd\x65\x78\x74\x5d\xf6\x6b\xe6\x1f\x35\xa9\xcb\x7e\x69\x2c\x8a\x4a\xc7\xbe\xb8\x9c\xd1\x45\x71\x2e\x8e\x43\x86\xf7\x60\xd2\xca\x88\x10\xf5\x02\xba\x72\xed\x5f\x87\x61\x42\xf1\xe4\xeb\xf0\x2d\x57\xae\xca\x03\x2d\x87\x2f\x71\x3f\xbb\x87\xe5\xa1\x20\xd1\x28\x3f\x26\x66\xd9\xcb\x21\x35\x10\x37\xde\x13\x76\x8b\x8a\x07\xd7\xef\x9c\x78\x76\xdf\xf5\xba\xbb\x91\xb7\xc0\x48\x28\x74\xc4\xd5\xda\xb5\x22\xf4\x2f\xeb\x25\xe5\x25\x4a\xa4\xc0\x30\x4c\x39\xec\x26\xbb\xc9\xe4\x57\x00\x00\x00\xff\xff\x16\xd4\xed\x89\x33\x0c\x00\x00") +var _yaoModelsAgentMessageModYao = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x56\x4d\x6f\xdb\x38\x10\xbd\xfb\x57\x0c\x78\xf2\x02\x4a\x36\x58\xec\x2e\x60\xdf\xd2\xf6\x92\x43\xd0\xa0\x4d\x4f\x41\x20\xd0\xd2\x58\x66\xc2\x0f\x87\x1c\xa5\x31\x0c\xff\xf7\x82\xb4\x24\x53\x31\x65\x44\x46\x7b\x31\xe0\x99\xd1\xf0\xbd\x99\x79\x43\x6e\x27\x00\x4c\x73\x85\x6c\x0e\xec\x16\x9d\xe3\x15\xb2\xcc\x1b\x25\x5f\xa0\x3c\xb2\x96\xe8\x0a\x2b\xd6\x24\x8c\xf6\xbe\xcf\x2b\x4e\xa0\xf6\x01\x40\x7c\x21\x11\x96\xc6\x82\x23\x63\x85\xae\xa0\x76\x68\x2f\x5e\x85\x13\xde\xd1\x84\xb9\x7d\x22\xe2\x95\x63\x73\x78\x60\xbc\x42\x4d\x2c\x03\xe6\x36\x8e\x50\xb1\xc7\xe0\x5e\xd4\x42\x92\xf0\x67\x90\xad\x31\x98\x2c\xf2\xd2\x68\xb9\x89\x6d\xce\x58\x62\x73\x98\xcd\x66\xb3\x26\xeb\x42\x7a\x2a\xdb\x03\xa9\x90\x3f\x57\x2d\x09\x60\x85\x51\xca\x1f\x39\x07\x76\xed\x7d\x50\x1c\x91\x60\xb0\x0b\xe9\x0a\x23\x6b\xa5\x03\xce\x09\x00\xc0\x36\xfc\x46\x15\x13\x65\x60\x13\x6c\xb4\x59\x07\xdb\xcd\x97\x83\xad\x2b\x62\x6c\x8c\x01\xd4\x64\x2e\x84\x2e\x2c\x7a\x0b\xac\xad\x50\xdc\x6e\xe0\x19\x37\x2c\x44\xef\xb2\xf4\xb9\x0d\xda\x3c\x75\xbe\x23\x5f\xfb\x04\x86\xa6\x91\x30\x80\xe5\x87\x16\x2f\x75\xd7\x26\x10\x25\x6a\x12\x4b\x81\x36\x4a\x85\xba\xa2\x15\x9b\xc3\xff\xff\x76\x36\x5d\x4b\xd9\x54\x7d\xc9\xa5\xc3\xce\x51\x87\x7c\x4d\xb7\x4e\xb2\xf1\x0d\x18\x47\x25\xcc\xdd\x00\x8f\x3b\x6e\xbb\xae\xf6\x7a\x31\x06\xbc\xd0\x25\xbe\x7d\x04\xbb\xc5\x97\x1a\xdd\x48\xf8\xdf\xf6\x1f\x0d\x31\x38\xb8\x83\x9a\x2a\x6b\xea\x75\x3f\xd1\x69\x2a\xad\x3c\x46\x32\x31\x12\x8f\x39\xa0\xae\x55\x8a\x41\x2f\x38\xc2\xde\x0e\x59\x3f\x9b\x69\x37\xc6\x03\xf3\x3b\xc1\xcb\x90\x3b\x27\x1c\x71\x4d\x7b\xc5\xff\xa6\x76\x04\xd8\x1f\x6f\xc4\x7d\x2f\x3c\x41\xc3\x67\x80\x29\xe1\x1b\x65\x20\x14\xaf\x30\x03\x69\x78\x29\x74\x95\x01\x19\x23\xf3\x82\x4b\x99\x81\x45\xb2\x02\x5f\xb9\xcc\x00\xa9\xb8\xfc\x2b\xd1\xaa\xff\xae\x06\x69\x9e\x64\xb4\xb6\x66\xed\x8e\x29\x3d\x39\xa3\x13\x84\xee\xfa\xd1\x09\x46\x3e\x1f\x5a\x12\xe8\x60\x5a\x18\x4d\xa8\x29\x83\xda\x1e\x23\x1f\x85\x72\x21\x4d\xf1\x3c\x4e\x04\x9f\xfc\x27\x43\x12\xd8\x3b\xdb\xc9\x1f\xa3\xe3\xf3\x86\x9f\x56\xfe\x7a\x19\x47\xe0\x3e\x7c\x33\xc4\xa0\xf1\x46\x14\x82\x98\x0b\xa3\x8b\xda\x86\x0d\xe5\xfb\xc0\xbd\x2e\xdc\x1f\x26\xd7\x49\x6d\x1c\xbf\xeb\xf6\xb3\x21\x8a\x71\x00\x4c\x9f\x8c\xd0\x40\x06\x2a\x24\xf0\x27\xff\xcd\x5f\x39\x71\x9b\xd2\xc2\x3f\x57\x49\x31\x9c\xc7\xce\xf9\x6d\xa9\x8b\x84\xec\x85\x26\xac\x7a\xf7\x57\x4b\xed\xfb\xd1\x37\x09\xa5\x18\x5b\xa2\x85\x9f\x82\x56\x42\x87\xeb\xe4\x4c\x6d\x28\x24\x5e\x72\xe2\x1f\x16\xf1\xed\xd1\x07\x71\xd1\xcb\x52\xf8\xa1\xe1\x12\xda\xc4\x30\xed\x56\x51\x2e\xca\x66\x31\xf9\xd3\x4f\x69\xfa\x50\xd7\x09\xc0\x63\xf3\xc2\x92\xcd\x3c\xce\x1b\x16\xe1\x6a\xee\xfe\x45\xc8\x57\xdc\x7d\xd5\x51\xf9\x94\x29\xf7\xd8\xf3\x7c\xc3\xcd\x65\x78\x74\x5d\xf6\x6b\xe6\x1f\x35\xa9\xcb\x7e\x69\x2c\x8a\x4a\xc7\xbe\xb8\x9c\xd1\x45\x71\x2e\x8e\x43\x86\xf7\x60\xd2\xca\x88\x10\xf5\x02\xba\x72\xed\x5f\x87\x61\x42\xf1\xe4\xeb\xf0\x2d\x57\xae\xca\x03\x2d\x87\x2f\x71\x3f\xbb\x87\xe5\xa1\x20\xd1\x28\x3f\x26\x66\xd9\xcb\x21\x35\x10\x37\xde\x13\x76\x8b\x8a\x07\xd7\xef\x9c\x78\x76\xdf\xf5\xba\xbb\x91\xb7\xc0\x48\x28\x74\xc4\xd5\xda\xb5\x22\xf4\x2f\xeb\x25\xe5\x25\x4a\x24\x6c\xad\xb0\x9b\xec\x26\x93\x5f\x01\x00\x00\xff\xff\x44\xb3\x47\xb8\x32\x0c\x00\x00") func yaoModelsAgentMessageModYaoBytes() ([]byte, error) { return bindataRead( @@ -2560,12 +2560,12 @@ func yaoModelsAgentMessageModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/message.mod.yao", size: 3123, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/agent/message.mod.yao", size: 3122, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _yaoModelsAgentResumeModYao = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x57\xcd\x6e\xdc\x36\x10\xbe\xfb\x29\x06\x3c\xb9\xa8\x9b\xba\x41\x51\xc0\x0b\xe4\x60\x24\x3d\xe4\x50\xa4\x88\xdb\x53\x60\x2c\xc6\xe2\x48\x62\x4d\x91\x32\x39\x6a\x2d\x18\x7e\xf7\x82\x94\x56\xa2\x7e\x76\xed\x5d\x38\x97\x05\x76\xfe\xf8\x7d\x33\xc3\xd1\xf0\xe9\x0c\x40\x18\xac\x48\x6c\x40\x7c\x25\xdf\x54\x24\x2e\x82\x4c\xe3\x1d\xe9\xb9\x50\x92\xcf\x9c\xaa\x59\x59\x33\xaa\x80\xf1\x4e\x13\xe4\xd6\x81\x67\xeb\x94\x29\x80\x1e\x29\x6b\x82\x15\x78\x46\xee\x74\x2e\x1a\xff\xec\x88\x5d\x0b\x79\x63\xb2\xa0\x47\xad\xb8\xed\x62\x33\x16\x5e\x6c\xe0\x9b\xc0\x82\x0c\x8b\x0b\x10\xbe\xf5\x4c\x95\xb8\x8d\xea\xbb\x46\x69\x56\xe1\x58\x76\x0d\x45\x91\x23\x94\xd6\xe8\x36\x95\x79\xeb\x58\x6c\xe0\xea\xea\xea\xaa\x8f\x7a\xa7\x03\xb7\xa7\x91\x65\x8c\xbf\x75\x3d\x2d\x10\x99\xad\xaa\x70\xe2\x06\xc4\x75\x50\x8d\x48\x33\xfb\x2f\xb9\xb6\xe3\x27\xe0\x39\x06\xcc\xac\x6e\x2a\x13\x91\x9e\x01\x00\x3c\xc5\xdf\x24\x89\x4a\x46\x3e\x51\xc6\x6d\x1d\x65\x9f\x3f\x8d\xb2\x21\xb1\xa9\x30\xc5\xd0\xb0\xfd\x49\x99\xcc\x51\x90\x40\xed\x54\x85\xae\x85\x7b\x6a\x45\xb4\x7e\xbe\x58\x3f\xb7\x43\xbd\x5d\x3b\xde\x73\xa8\xca\x0a\x84\xbe\x80\x7b\x90\xfc\x6d\xd4\x43\x43\x7d\x3a\x20\xa4\xc3\x49\x50\x92\x0c\xab\x5c\x91\x4b\xe2\x91\x29\xb8\x14\x1b\xf8\xed\xd7\x41\x66\x1a\xad\xfb\xdc\xe7\xa8\x3d\x0d\x8a\x26\x46\xed\x6b\x76\x90\x51\x56\x22\x1f\xc7\xe7\x63\x89\xbc\x8f\xcd\x9f\xe8\x42\x3e\xb3\xb9\xc9\x51\xe0\x95\x91\xf4\xf8\x1a\xec\x8e\x1e\x1a\xf2\x47\xc2\xff\xda\x39\xed\x63\xb0\xa6\xfe\x3e\xe8\xd1\x7b\xe5\x19\xcd\x91\xf8\xaf\x77\x6e\xfb\x18\x8c\x06\xfd\x84\x30\x05\x70\xa9\x3c\x78\xa6\x7a\x85\xd4\xfb\xcb\xcb\x37\x64\xe5\x19\xb3\xfb\xe3\x18\xdd\x04\x97\x7d\x6c\x3a\xa5\xb1\x32\xdc\xa0\x38\xe3\x22\x97\x61\xf8\x7d\xef\x2a\x75\x7c\xea\xd8\xd7\xa7\xd0\xea\x6f\xc4\xe1\xfb\xe2\xfb\x0c\xc0\x79\x20\x78\xfd\xfe\x1a\x32\xd4\xda\xff\xf0\x6a\x72\xbb\xd1\x7c\x0a\x37\x49\x35\x97\x4b\x5e\xca\x30\x15\x93\x01\x34\x25\xf6\x69\xea\x96\x90\xfa\x88\x5a\x43\x8c\x0a\xe7\x97\x1f\x9c\xb5\x7c\x01\xbf\xfc\xf8\xc1\x90\x67\x92\x09\xa7\xbd\xc5\x91\x94\x63\xa3\x43\xac\xcb\x83\xf8\x23\xd4\x05\x70\x32\x4d\xb5\x82\xfa\xaf\x89\xf1\xa4\xc3\xa8\x86\x69\x28\xbb\xfb\xfa\x7e\xeb\x25\x31\xab\x75\xc3\x83\x09\x80\x28\xad\xbd\xdf\x66\x8e\x90\x29\x15\x6b\x5d\xa5\x7f\xd9\x5a\xbd\xf0\x32\xf4\x38\x09\x25\x49\x53\x11\xe2\xf4\xa2\xdb\xb7\x6d\x60\x6e\xfc\xab\xd3\x74\x33\x33\x9f\x8c\xc6\xf8\x8d\xea\x02\xc2\x79\xd8\x0a\x20\x74\x89\x73\x4d\xcd\x24\xc1\x3a\xc8\x51\x69\x92\x80\x8e\xe2\x9a\x32\x29\xf7\x98\x54\x91\x78\x85\xe5\xa0\xf3\x12\x6f\xc9\x7a\x5a\xad\x81\xf4\x3f\x7e\x32\x31\x86\x2d\x61\x6a\x3d\x6f\x8e\x18\x0c\x24\x32\xae\x36\xef\x8b\x60\x6c\xc3\xc7\xa0\xf9\x32\x33\x9f\xc3\xe9\xc2\x45\x3c\x70\x5e\xa3\x63\x85\x7a\xfd\x5a\xbd\xdc\x1c\x35\x66\xb4\xf5\x06\x6b\x5f\xda\xd7\x23\xbc\x09\x6e\x70\xb3\x70\x4b\x91\x46\x93\x88\x71\x17\xbe\xdf\x50\xbb\x85\xef\x34\xbc\xe4\x9c\x75\x4b\x98\x9c\xde\xa7\x11\xe6\xef\x53\xeb\x04\x5d\xd4\x40\x45\xde\x63\x41\xa0\xf2\xbe\x71\x4f\x4c\x62\x58\x19\x4c\xb6\x32\x8a\x0e\xcc\xd0\x85\xcf\xa2\xca\x4e\x92\x83\xff\x14\x97\xca\x40\xbf\xe9\xec\x9f\x9d\x07\x01\x56\xc4\x38\xed\xde\x17\xea\xfb\xc7\xc2\x21\xdd\x2f\xa4\x54\xdd\xb3\x02\x96\x81\x57\xf3\x76\xd6\x4f\x34\xe1\x48\x63\x70\x0d\x9b\x7d\x87\x32\xee\x9f\xc3\xbf\x04\x59\x89\xfe\x8b\x49\xd2\x53\x59\xd9\x61\xdb\x6e\x5b\xb4\xef\xe2\xfb\xe2\x5d\x74\x1e\x4c\xc2\xf6\xbe\xb6\xd1\xe6\xd6\x91\x2a\x4c\xaa\x4b\xd3\x35\x2e\x62\x27\xe3\x18\x23\xcc\xc1\xac\x2f\x79\x09\xa2\x89\xc1\x90\xae\xee\x19\x14\xa7\x1d\x1d\x7c\x06\x3d\xf6\x6f\xac\xed\x6e\x17\xf6\xf4\x90\x56\x6d\x78\x47\x4d\x96\xe5\xa4\x67\x6f\x57\x9a\x36\xcc\xd8\xb5\xca\x7f\x0e\x9a\xe4\x9d\xd9\xf5\x68\xd8\x2f\x67\x6d\x3a\x2b\xfb\x30\xf9\x9f\x40\xb0\xaa\xc8\x33\x56\xb5\xdf\xad\x2d\xe1\x3d\x99\xf3\x36\x7c\x03\x39\x92\x8d\x0d\x0d\xcf\x67\xcf\x67\xff\x07\x00\x00\xff\xff\xe7\xf7\x68\x75\x39\x0f\x00\x00") +var _yaoModelsAgentResumeModYao = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x57\xcd\x6e\xdc\x36\x10\xbe\xfb\x29\x06\x3c\xb9\xa8\x9b\xba\x41\x51\xc0\x0b\xe4\x60\x24\x3d\xe4\x50\xa4\x88\xdb\x53\x60\x2c\xc6\xe2\x48\x62\x4d\x91\x32\x39\x6a\x2d\x18\x7e\xf7\x82\x94\x56\xa2\x7e\x76\xed\x5d\x38\x97\x05\x76\xfe\xf8\x7d\x33\xc3\xd1\xf0\xe9\x0c\x40\x18\xac\x48\x6c\x40\x7c\x25\xdf\x54\x24\x2e\x82\x4c\xe3\x1d\xe9\xb9\x50\x92\xcf\x9c\xaa\x59\x59\x33\xaa\x80\xf1\x4e\x13\xe4\xd6\x81\x67\xeb\x94\x29\x80\x1e\x29\x6b\x82\x15\x78\x46\xee\x74\x2e\x1a\xff\xec\x88\x5d\x0b\x79\x63\xb2\xa0\x47\xad\xb8\xed\x62\x33\x16\x5e\x6c\xe0\x9b\xc0\x82\x0c\x8b\x0b\x10\xbe\xf5\x4c\x95\xb8\x8d\xea\xbb\x46\x69\x56\xe1\x58\x76\x0d\x45\x91\x23\x94\xd6\xe8\x36\x95\x79\xeb\x58\x6c\xe0\xea\xea\xea\xaa\x8f\x7a\xa7\x03\xb7\xa7\x91\x65\x8c\xbf\x75\x3d\x2d\x10\x99\xad\xaa\x70\xe2\x06\xc4\x75\x50\x8d\x48\x33\xfb\x2f\xb9\xb6\xe3\x27\xe0\x39\x06\xcc\xac\x6e\x2a\x13\x91\x9e\x01\x00\x3c\xc5\xdf\x24\x89\x4a\x46\x3e\x51\xc6\x6d\x1d\x65\x9f\x3f\x8d\xb2\x21\xb1\xa9\x30\xc5\xd0\xb0\xfd\x49\x99\xcc\x51\x90\x40\xed\x54\x85\xae\x85\x7b\x6a\x45\xb4\x7e\xbe\x58\x3f\xb7\x43\xbd\x5d\x3b\xde\x73\xa8\xca\x0a\x84\xbe\x80\x7b\x90\xfc\x6d\xd4\x43\x43\x7d\x3a\x20\xa4\xc3\x49\x50\x92\x0c\xab\x5c\x91\x4b\xe2\x91\x29\xb8\x14\x1b\xf8\xed\xd7\x41\x66\x1a\xad\xfb\xdc\xe7\xa8\x3d\x0d\x8a\x26\x46\xed\x6b\x76\x90\x51\x56\x22\x1f\xc7\xe7\x63\x89\xbc\x8f\xcd\x9f\xe8\x42\x3e\xb3\xb9\xc9\x51\xe0\x95\x91\xf4\xf8\x1a\xec\x8e\x1e\x1a\xf2\x47\xc2\xff\xda\x39\xed\x63\xb0\xa6\xfe\x3e\xe8\xd1\x7b\xe5\x19\xcd\x91\xf8\xaf\x77\x6e\xfb\x18\x8c\x06\xfd\x84\x30\x05\x70\xa9\x3c\x78\xa6\x7a\x85\xd4\xfb\xcb\xcb\x37\x64\xe5\x19\xb3\xfb\xe3\x18\xdd\x04\x97\x7d\x6c\x3a\xa5\xb1\x32\xdc\xa0\x38\xe3\x22\x97\x61\xf8\x7d\xef\x2a\x75\x7c\xea\xd8\xd7\xa7\xd0\xea\x6f\xc4\xe1\xfb\xe2\xfb\x0c\xc0\x79\x20\x78\xfd\xfe\x1a\x32\xd4\xda\xff\xf0\x6a\x72\xbb\xd1\x7c\x0a\x37\x49\x35\x97\x4b\x5e\xca\x30\x15\x93\x01\x34\x25\xf6\x69\xea\x96\x90\xfa\x88\x5a\x43\x8c\x0a\xe7\x97\x1f\x9c\xb5\x7c\x01\xbf\xfc\xf8\xc1\x90\x67\x92\x09\xa7\xbd\xc5\x91\x94\x63\xa3\x43\xac\xcb\x83\xf8\x23\xd4\x05\x70\x32\x4d\xb5\x82\xfa\xaf\x89\xf1\xa4\xc3\xa8\x86\x69\x28\xbb\xfb\xfa\x7e\xeb\x25\x31\xab\x75\xc3\x83\x09\x80\x28\xad\xbd\xdf\x66\x8e\x90\x29\x15\x6b\x5d\xa5\x7f\xd9\x5a\xbd\xf0\x32\xf4\x38\x09\x25\x49\x53\x11\xe2\xf4\xa2\xdb\xb7\x6d\x60\x6e\xfc\xab\xd3\x74\x33\x33\x9f\x8c\xc6\xf8\x8d\xea\x02\xc2\x79\xd8\x0a\x20\x74\x89\x73\x4d\xcd\x24\xc1\x3a\xc8\x51\x69\x92\x80\x8e\xe2\x9a\x32\x29\xf7\x98\x54\x91\x78\x85\xe5\xa0\xf3\x12\x6f\xc9\x7a\x5a\xad\x81\xf4\x3f\x7e\x32\x31\x86\x2d\x61\x6a\x3d\x6f\x8e\x18\x0c\x24\x32\xae\x36\xef\x8b\x60\x6c\xc3\xc7\xa0\xf9\x32\x33\x9f\xc3\xe9\xc2\x45\x3c\x70\x5e\xa3\x63\x85\x7a\xfd\x5a\xbd\xdc\x1c\x35\x66\xb4\xf5\x06\x6b\x5f\xda\xd7\x23\xbc\x09\x6e\x70\xb3\x70\x4b\x91\x46\x93\x88\x71\x17\xbe\xdf\x50\xbb\x85\xef\x34\xbc\xe4\x9c\x75\x4b\x98\x9c\xde\xa7\x11\xe6\xef\x53\xeb\x04\x5d\xd4\x40\x45\xde\x63\x41\xa0\xf2\xbe\x71\x4f\x4c\x62\x58\x19\x4c\xb6\x32\x8a\x0e\xcc\xd0\x85\xcf\xa2\xca\x4e\x92\x83\xff\x14\x97\xca\x40\xbf\xe9\xec\x9f\x9d\x07\x01\x56\xc4\x38\xed\xde\x17\xea\xfb\xc7\xc2\x21\xdd\x2f\xa4\x54\xdd\xb3\x02\x96\x81\x57\xf3\x76\xd6\x4f\x34\xe1\x48\x63\x70\x0d\x9b\x7d\x87\x32\xee\x9f\xc3\xbf\x04\x59\x89\xfe\x8b\x49\xd2\x53\x59\xd9\x61\xdb\x6e\x5b\xb4\xef\xe2\xfb\xe2\x5d\x74\x1e\x4c\xc2\xf6\xbe\xb6\xd1\xe6\xd6\x91\x2a\x4c\xaa\x4b\xd3\x35\x2e\x62\x27\xe3\x18\x23\xcc\xc1\xac\x2f\x79\x09\xa2\x89\xc1\x90\xae\xee\x19\x14\xa7\x1d\x1d\x7c\x06\x3d\xf6\x6f\xac\xed\x6e\x17\xf6\xf4\x90\x56\x6d\x78\x47\x4d\x96\xe5\xa4\x67\x6f\x57\x9a\x36\xcc\xd8\xb5\xca\x7f\x0e\x9a\xe4\x9d\xd9\xf5\x68\xd8\x2f\x67\x6d\x3a\x2b\xfb\x30\xf9\x9f\x40\xb0\xaa\xc8\x33\x56\xb5\xdf\xad\x2d\xe1\x3d\x99\xf3\x36\x7c\x03\x99\x76\x52\x78\x3e\x7b\x3e\xfb\x3f\x00\x00\xff\xff\x77\x1a\x20\x0c\x38\x0f\x00\x00") func yaoModelsAgentResumeModYaoBytes() ([]byte, error) { return bindataRead( @@ -2580,7 +2580,7 @@ func yaoModelsAgentResumeModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/agent/resume.mod.yao", size: 3897, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/agent/resume.mod.yao", size: 3896, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2600,7 +2600,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/attachment.mod.yao", size: 4687, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2620,7 +2620,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/audit.mod.yao", size: 5588, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2640,7 +2640,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/config.mod.yao", size: 1649, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2660,7 +2660,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/dsl.mod.yao", size: 3826, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2680,7 +2680,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/invitation.mod.yao", size: 6693, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2700,7 +2700,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/job/category.mod.yao", size: 2041, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2720,7 +2720,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/job/execution.mod.yao", size: 7201, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2740,7 +2740,7 @@ func yaoModelsJobJobModYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/models/job/job.mod.yao", size: 6330, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/job/job.mod.yao", size: 6330, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2760,7 +2760,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/job/log.mod.yao", size: 4711, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2780,7 +2780,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/kb/collection.mod.yao", size: 5390, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2800,7 +2800,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/kb/document.mod.yao", size: 9906, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2820,7 +2820,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/member.mod.yao", size: 14798, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2840,7 +2840,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/role.mod.yao", size: 6434, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2860,7 +2860,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/team.mod.yao", size: 15823, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2880,7 +2880,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/user/oauth_account.mod.yao", size: 6928, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2900,7 +2900,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/user/type.mod.yao", size: 7502, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2920,7 +2920,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/models/user.mod.yao", size: 12335, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2940,7 +2940,7 @@ func yaoReleaseAppYaz() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/release/app.yaz", size: 181682, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/release/app.yaz", size: 181682, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2960,7 +2960,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/agent/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -2980,7 +2980,7 @@ func yaoStoresAgentMemoryBadgerYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/agent/memory.badger.yao", size: 352, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/agent/memory.badger.yao", size: 352, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3000,7 +3000,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/cache.lru.yao", size: 285, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3020,7 +3020,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/kb/cache.lru.yao", size: 304, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3040,7 +3040,7 @@ func yaoStoresKbStoreBadgerYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/kb/store.badger.yao", size: 349, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/kb/store.badger.yao", size: 349, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3060,7 +3060,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/oauth/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3080,7 +3080,7 @@ func yaoStoresOauthClientBadgerYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/oauth/client.badger.yao", size: 352, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/oauth/client.badger.yao", size: 352, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3100,7 +3100,7 @@ func yaoStoresOauthStoreBadgerYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/oauth/store.badger.yao", size: 376, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/oauth/store.badger.yao", size: 376, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3120,7 +3120,7 @@ func yaoStoresStoreBadgerYao() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "yao/stores/store.badger.yao", size: 341, mode: os.FileMode(420), modTime: time.Unix(1765246552, 0)} + info := bindataFileInfo{name: "yao/stores/store.badger.yao", size: 341, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -3140,7 +3140,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(1765246552, 0)} + info := bindataFileInfo{name: "yao/uploaders/attachment.local.yao", size: 1163, mode: os.FileMode(420), modTime: time.Unix(1765248590, 0)} a := &asset{bytes: bytes, info: info} return a, nil } diff --git a/yao/models/agent/message.mod.yao b/yao/models/agent/message.mod.yao index 07e92e27..938ce0ac 100644 --- a/yao/models/agent/message.mod.yao +++ b/yao/models/agent/message.mod.yao @@ -129,6 +129,5 @@ "comment": "Index for message ordering within chat" } ], - "option": { "timestamps": true, "soft_deletes": false } + "option": { "timestamps": true, "soft_deletes": true } } - diff --git a/yao/models/agent/resume.mod.yao b/yao/models/agent/resume.mod.yao index 4ebedd62..674a7919 100644 --- a/yao/models/agent/resume.mod.yao +++ b/yao/models/agent/resume.mod.yao @@ -166,5 +166,5 @@ "comment": "Index for resume ordering within request" } ], - "option": { "timestamps": true, "soft_deletes": false } + "option": { "timestamps": true, "soft_deletes": true } }