fix(seeder): correct log generation fields

- Parse provider group models from API response string and expose as slice
- Send `model` field (not `model_name`) when creating logs
- Use API key ID as `provider_id` instead of provider group ID
- Restrict reset behavior to resources matching seeder tag/prefix
- Refactor usage sample generation to accept a context struct

cmd/seeder/seeder.go

@@ -11,12 +11,25 @@ var seededNamespaces []string
 // seededProviderGroups stores created provider groups for later use
 var seededProviderGroups []ProviderGroupResponse
 
+// seededProviders stores created providers (API keys) per group for usage samples
+var seededProviders map[uint][]APIKeyResponse
+
 // seededMasters stores created masters for later use
 var seededMasters []MasterResponse
 
 // seededKeys stores created keys per master for usage samples
 var seededKeys map[uint][]KeyResponse
 
+// matchesSeederTag checks if a string contains the current seeder tag
+func (s *Seeder) matchesSeederTag(text string) bool {
+	return strings.Contains(text, s.seederTag)
+}
+
+// matchesSeederPrefix checks if a name matches seeder naming convention
+func (s *Seeder) matchesSeederPrefix(name string) bool {
+	return strings.HasPrefix(name, "demo-") || strings.HasPrefix(name, "seeder-") || strings.HasSuffix(name, "-demo")
+}
+
 func (s *Seeder) seedNamespaces() error {
 	gen := NewGenerator(s.rng, s.seederTag, s.cfg.Profile)
 	namespaces := gen.GenerateNamespaces(s.profile.Namespaces)
@@ -25,7 +38,6 @@ func (s *Seeder) seedNamespaces() error {
 	existing, err := s.client.ListNamespaces()
 	if err != nil {
 		if s.cfg.DryRun {
-			// In dry-run mode, continue without checking existing
 			existing = []NamespaceResponse{}
 			fmt.Printf("  [DRY-RUN] Unable to list existing namespaces, proceeding anyway\n")
 		} else {
@@ -42,8 +54,8 @@ func (s *Seeder) seedNamespaces() error {
 
 	for _, ns := range namespaces {
 		if existingNs, exists := existingMap[ns.Name]; exists {
-			// Check if we should reset
-			if s.cfg.Reset && HasSeederTag(existingNs.Description, s.seederTag) {
+			// Check if we should reset - only reset if tag matches
+			if s.cfg.Reset && s.matchesSeederTag(existingNs.Description) {
 				if err := s.client.DeleteNamespace(existingNs.ID); err != nil {
 					return fmt.Errorf("delete namespace %s: %w", ns.Name, err)
 				}
@@ -63,7 +75,6 @@ func (s *Seeder) seedNamespaces() error {
 		// Create namespace
 		created, err := s.client.CreateNamespace(ns)
 		if err != nil {
-			// Check if it's a conflict (already exists)
 			if apiErr, ok := err.(*APIError); ok && apiErr.IsConflict() {
 				if s.cfg.Verbose {
 					fmt.Printf("  ○ %s (exists, skipped)\n", ns.Name)
@@ -113,8 +124,9 @@ func (s *Seeder) seedProviderGroups() error {
 
 	for _, group := range groups {
 		if existingGroup, exists := existingMap[group.Name]; exists {
-			// Check if we should reset (check name prefix for seeder tag)
-			if s.cfg.Reset && strings.HasPrefix(group.Name, "demo-") {
+			// Check if we should reset - match by seeder naming convention
+			// Provider groups use name suffix like "openai-demo", "anthropic-demo"
+			if s.cfg.Reset && s.matchesSeederPrefix(group.Name) {
 				if err := s.client.DeleteProviderGroup(existingGroup.ID); err != nil {
 					return fmt.Errorf("delete provider group %s: %w", group.Name, err)
 				}
@@ -158,13 +170,15 @@ func (s *Seeder) seedProviderGroups() error {
 
 func (s *Seeder) seedProviders() error {
 	gen := NewGenerator(s.rng, s.seederTag, s.cfg.Profile)
+	seededProviders = make(map[uint][]APIKeyResponse)
 
 	for _, group := range seededProviderGroups {
 		providers := gen.GenerateProviders(group.ID, group.Name, s.profile.ProvidersPerGroup)
+		groupProviders := make([]APIKeyResponse, 0, len(providers))
 
 		createdCount := 0
 		for _, provider := range providers {
-			_, err := s.client.CreateAPIKey(provider)
+			created, err := s.client.CreateAPIKey(provider)
 			if err != nil {
 				if apiErr, ok := err.(*APIError); ok && apiErr.IsConflict() {
 					s.summary.Providers.Skipped++
@@ -174,8 +188,13 @@ func (s *Seeder) seedProviders() error {
 			}
 			s.summary.Providers.Created++
 			createdCount++
+			if created != nil {
+				groupProviders = append(groupProviders, *created)
+			}
 		}
 
+		seededProviders[group.ID] = groupProviders
+
 		if s.cfg.Verbose || s.cfg.DryRun {
 			fmt.Printf("  ✓ %s: %d providers created\n", group.Name, createdCount)
 		}
@@ -206,7 +225,9 @@ func (s *Seeder) seedModels() error {
 
 	for _, model := range models {
 		if existingModel, exists := existingMap[model.Name]; exists {
-			if s.cfg.Reset {
+			// Models are shared resources - only reset if explicitly requested
+			// and the model name matches seeder pattern (unlikely for real models)
+			if s.cfg.Reset && s.matchesSeederPrefix(model.Name) {
 				if err := s.client.DeleteModel(existingModel.ID); err != nil {
 					return fmt.Errorf("delete model %s: %w", model.Name, err)
 				}
@@ -269,7 +290,8 @@ func (s *Seeder) seedBindings() error {
 	for _, binding := range bindings {
 		key := fmt.Sprintf("%s:%s:%d", binding.Namespace, binding.PublicModel, binding.GroupID)
 		if existingBinding, exists := existingMap[key]; exists {
-			if s.cfg.Reset {
+			// Only reset bindings in seeder namespaces
+			if s.cfg.Reset && s.matchesSeederPrefix(binding.Namespace) {
 				if err := s.client.DeleteBinding(existingBinding.ID); err != nil {
 					return fmt.Errorf("delete binding: %w", err)
 				}
@@ -321,7 +343,8 @@ func (s *Seeder) seedMasters() error {
 
 	for _, master := range masters {
 		if existingMaster, exists := existingMap[master.Name]; exists {
-			if s.cfg.Reset && strings.HasSuffix(master.Name, "-demo") {
+			// Reset masters with seeder naming pattern
+			if s.cfg.Reset && s.matchesSeederPrefix(master.Name) {
 				if err := s.client.DeleteMaster(existingMaster.ID); err != nil {
 					return fmt.Errorf("delete master %s: %w", master.Name, err)
 				}
@@ -402,13 +425,26 @@ func (s *Seeder) seedKeys() error {
 func (s *Seeder) seedUsageSamples() error {
 	gen := NewGenerator(s.rng, s.seederTag, s.cfg.Profile)
 
-	logs := gen.GenerateUsageSamples(seededMasters, seededKeys, seededProviderGroups, s.cfg.UsageDays)
+	ctx := UsageSampleContext{
+		Masters:   seededMasters,
+		Keys:      seededKeys,
+		Groups:    seededProviderGroups,
+		Providers: seededProviders,
+		UsageDays: s.cfg.UsageDays,
+	}
+
+	logs := gen.GenerateUsageSamples(ctx)
 
 	if len(logs) == 0 {
 		fmt.Printf("  ○ No masters or groups to generate samples for\n")
 		return nil
 	}
 
+	// Note about timestamps
+	if s.cfg.Verbose {
+		fmt.Printf("  ⚠ Note: Usage samples will have current timestamp (API does not support historical timestamps)\n")
+	}
+
 	// Batch insert logs
 	batchSize := 100
 	for i := 0; i < len(logs); i += batchSize {