ace-support-models 0.11.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ebc7ef6c3d124c4b7fa54702c0e856793c9e36fa376557f2d4bf6b9811dcf03
-  data.tar.gz: f6c20651c3eea1364732f66a4d7732f2a8e23b84631819d8aada3dec9b6c5cd1
+  metadata.gz: 90738d0888e9e24b0a22f0febc4cd012472e31598e63f2f6dedcb59111966571
+  data.tar.gz: 391d5d2e24473b8e9377603c9ab33f42500397de98616d02ba530117a991787e
 SHA512:
-  metadata.gz: 92b7a7ba187eb9a70d728ea4ac0095bbde6ed573c25501b82e763bd71676cf1222f3a79b438a0e40e8e3bb0ea254a778f6c202c37d18cee6403677846f390e96
-  data.tar.gz: f13a21c74ccda53367251d01c23988ba86dfecc919671f8fc0d0cfd451c6a14acc18acd45f3545a44929aefb22f1a541877ccacc9a54a2553aeec7e25cde8faf
+  metadata.gz: b0c49eaebca896bf7f5ec8a522b952e187a4c9031efeb839036d01fb3505857d8522aef74ebb9bd20596b526547c967750ccfeaa5bec01b39e598e570feb2a04
+  data.tar.gz: 80a8dc203bfa7f0159b9d3056a9c7d0d6ac412a3b57a85f9b361cd5bf4dee161f014f2ff5878d73485018ab235557d0d36d9d6b8e563eb03e933b66ce3f1ce63

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.12.0] - 2026-04-24
+
+### Added
+- Synced provider context and output token limits from the models catalog into managed provider YAML via `limits.default` plus per-model overrides.
+
+### Fixed
+- Kept normal provider sync constrained to the tracked model set while still updating limit metadata, and fixed exact-suffix model matching so repeated sync runs stay idempotent.
+
+## [0.11.3] - 2026-04-23
+
+### Technical
+- Kept retained provider smoke coverage on one explicit `XDG_CACHE_HOME` across `sync`, `list`, and `show` so the scenario reads a single deterministic cache root.
+
 ## [0.11.2] - 2026-04-16
 
 ### Fixed

data/lib/ace/support/models/atoms/provider_config_reader.rb

@@ -111,6 +111,24 @@ module Ace
               end
             end
 
+            # Extract normalized limit configuration from a provider config.
+            # @param config [Hash]
+            # @return [Hash] normalized {"default"=>{"context"=>..., "output"=>...}, "models"=>{...}}
+            def extract_limits(config)
+              limits = config["limits"]
+              return {} unless limits.is_a?(Hash)
+
+              normalized = {}
+
+              default_limits = normalize_limit_entry(limits["default"])
+              normalized["default"] = default_limits if default_limits.any?
+
+              model_limits = normalize_model_limits(limits["models"])
+              normalized["models"] = model_limits if model_limits.any?
+
+              normalized
+            end
+
             # Extract models.dev provider ID from config
             # Falls back to provider name if not specified
             # @param config [Hash] Provider config
@@ -138,6 +156,38 @@ module Ace
 
             private
 
+            def normalize_model_limits(model_limits)
+              return {} unless model_limits.is_a?(Hash)
+
+              model_limits.each_with_object({}) do |(model, entry), normalized|
+                next if model.to_s.strip.empty?
+
+                normalized_entry = normalize_limit_entry(entry)
+                normalized[model.to_s] = normalized_entry if normalized_entry.any?
+              end
+            end
+
+            def normalize_limit_entry(entry)
+              return {} unless entry.is_a?(Hash)
+
+              normalized = {}
+
+              context = normalize_limit_value(entry["context"] || entry[:context])
+              output = normalize_limit_value(entry["output"] || entry[:output])
+
+              normalized["context"] = context unless context.nil?
+              normalized["output"] = output unless output.nil?
+              normalized
+            end
+
+            def normalize_limit_value(value)
+              return nil if value.nil?
+
+              Integer(value)
+            rescue ArgumentError, TypeError
+              nil
+            end
+
             def project_config_dir
               # Use ace-core if available and has project_root method
               if defined?(Ace::Core) && Ace::Core.respond_to?(:project_root)

data/lib/ace/support/models/atoms/provider_config_writer.rb

@@ -18,11 +18,9 @@ module Ace
             # @return [Boolean] true on success
             # @raise [ConfigError] on write errors
             def update_models(path, models)
-              content = read_file_content(path)
-              raise ConfigError, "Config file not found: #{path}" unless content
-
-              updated_content = replace_models_section(content, models)
-              write_file(path, updated_content)
+              config = read_config(path)
+              config["models"] = Array(models)
+              write(path, config)
               true
             end
 
@@ -32,7 +30,7 @@ module Ace
             # @return [Boolean] true on success
             def write(path, config)
               ensure_directory(File.dirname(path))
-              content = YAML.dump(config)
+              content = format_config(config)
               write_file(path, content)
               true
             end
@@ -55,11 +53,9 @@ module Ace
             # @return [Boolean] true on success
             # @raise [ConfigError] on write errors
             def update_last_synced(path, date = Date.today)
-              content = read_file_content(path)
-              raise ConfigError, "Config file not found: #{path}" unless content
-
-              updated_content = replace_or_add_field(content, "last_synced", date.to_s)
-              write_file(path, updated_content)
+              config = read_config(path)
+              config["last_synced"] = date
+              write(path, config)
               true
             end
 
@@ -68,29 +64,30 @@ module Ace
             # @param models [Array<String>] New list of model IDs
             # @param date [Date] Date to set for last_synced
             # @return [Boolean] true on success
-            def update_models_and_sync_date(path, models, date = Date.today)
-              content = read_file_content(path)
-              raise ConfigError, "Config file not found: #{path}" unless content
+            def update_models_and_sync_date(path, models, date = Date.today, limits: nil)
+              config = read_config(path)
+              config["models"] = Array(models)
+              config["last_synced"] = date
+
+              unless limits.nil?
+                normalized_limits = normalize_limits(limits)
+                if normalized_limits.empty?
+                  config.delete("limits")
+                else
+                  config["limits"] = normalized_limits
+                end
+                config.delete("context_limit")
+              end
 
-              updated_content = replace_models_section(content, models)
-              updated_content = replace_or_add_field(updated_content, "last_synced", date.to_s)
-              write_file(path, updated_content)
+              write(path, config)
               true
             end
 
             private
 
-            def read_file_content(path)
-              return nil unless File.exist?(path)
-
-              File.read(path)
-            rescue Errno::EACCES => e
-              raise ConfigError, "Permission denied reading #{path}: #{e.message}"
-            end
-
             def write_file(path, content)
               # Validate YAML before writing to catch regex manipulation errors
-              YAML.safe_load(content, permitted_classes: [Symbol, Date])
+              YAML.safe_load(content, permitted_classes: [Symbol, Date], aliases: true)
               File.write(path, content)
             rescue Psych::SyntaxError => e
               raise ConfigError, "Generated invalid YAML for #{path}: #{e.message}"
@@ -108,119 +105,98 @@ module Ace
               raise ConfigError, "Permission denied creating directory #{dir}: #{e.message}"
             end
 
-            # Replace the models section in YAML content while preserving structure
-            # @param content [String] Original YAML content
-            # @param models [Array<String>] New models list
-            # @return [String] Updated content
-            # @raise [ConfigError] if unsupported YAML styles are detected
-            def replace_models_section(content, models)
-              # Check for flow-style arrays which are not supported
-              if /^\s*models:\s*\[/m.match?(content)
-                raise ConfigError, "Flow-style arrays (models: [...]) are not supported for auto-update. " \
-                                   "Please convert to block style (models: followed by list items)."
-              end
+            def read_config(path)
+              raise ConfigError, "Config file not found: #{path}" unless File.exist?(path)
 
-              # Check for inline comments on models: line which are not preserved
-              if /^\s*models:\s*#/m.match?(content)
-                raise ConfigError, "Inline comments on 'models:' line (e.g., 'models: # comment') are not supported. " \
-                                   "Please move the comment to a separate line above 'models:'."
-              end
+              YAML.safe_load(File.read(path), permitted_classes: [Symbol, Date], aliases: true) || {}
+            rescue Errno::EACCES => e
+              raise ConfigError, "Permission denied reading #{path}: #{e.message}"
+            rescue Psych::SyntaxError => e
+              raise ConfigError, "Invalid YAML in #{path}: #{e.message}"
+            end
 
-              lines = content.lines
-              result = []
-              in_models_section = false
-              models_base_indent = 0
-
-              lines.each do |line|
-                # Detect start of models section (with or without items on same line)
-                if line =~ /^(\s*)models:\s*$/
-                  in_models_section = true
-                  models_base_indent = $1.length
-                  result << line
-
-                  # Add new models with standard YAML indent
-                  models.each do |model|
-                    result << "#{" " * (models_base_indent + 2)}- #{model}\n"
-                  end
-                  next
-                end
+            def normalize_limits(limits)
+              return {} unless limits.is_a?(Hash)
 
-                # If in models section, skip old model items
-                if in_models_section
-                  # Check if this line is a list item (model entry)
-                  if line =~ /^(\s*)-\s+/
-                    item_indent = $1.length
-                    # Skip if it's at the expected indent for models (base + 0 or base + 2)
-                    if item_indent == models_base_indent || item_indent == models_base_indent + 2
-                      next
-                    end
-                  end
-
-                  # Empty line - keep but stay in models section
-                  if line.strip.empty?
-                    result << line
-                    next
-                  end
-
-                  # A new key at base level (not indented more) ends models section
-                  if line =~ /^(\s*)\S/
-                    current_indent = $1.length
-                    if current_indent <= models_base_indent
-                      in_models_section = false
-                      result << line
-                    end
-                    # Otherwise skip (shouldn't happen for well-formed YAML)
-                  end
-                  next
-                end
+              normalized = {}
 
-                result << line
-              end
+              default_limits = normalize_limit_entry(limits["default"] || limits[:default])
+              normalized["default"] = default_limits if default_limits.any?
 
-              result.join
+              models = limits["models"] || limits[:models]
+              normalized_models = normalize_model_limits(models)
+              normalized["models"] = normalized_models if normalized_models.any?
+
+              normalized
             end
 
-            # Replace or add a field in YAML content
-            # @param content [String] Original YAML content
-            # @param field_name [String] Field name to replace or add
-            # @param value [String] New value
-            # @return [String] Updated content
-            def replace_or_add_field(content, field_name, value)
-              lines = content.lines
-
-              # Try to find and replace existing field
-              field_found = false
-              result = lines.map do |line|
-                if line =~ /^(\s*)#{Regexp.escape(field_name)}:\s*(.*)$/
-                  field_found = true
-                  "#{$1}#{field_name}: #{value}\n"
-                else
-                  line
-                end
+            def normalize_model_limits(models)
+              return {} unless models.is_a?(Hash)
+
+              models.each_with_object({}) do |(model, entry), normalized|
+                next if model.to_s.strip.empty?
+
+                normalized_entry = normalize_limit_entry(entry)
+                normalized[model.to_s] = normalized_entry if normalized_entry.any?
+              end.sort.to_h
+            end
+
+            def normalize_limit_entry(entry)
+              return {} unless entry.is_a?(Hash)
+
+              normalized = {}
+
+              context = normalize_limit_value(entry["context"] || entry[:context])
+              output = normalize_limit_value(entry["output"] || entry[:output])
+
+              normalized["context"] = context unless context.nil?
+              normalized["output"] = output unless output.nil?
+              normalized
+            end
+
+            def normalize_limit_value(value)
+              return nil if value.nil?
+
+              Integer(value)
+            rescue ArgumentError, TypeError
+              nil
+            end
+
+            def format_config(config)
+              YAML.dump(canonicalize_config(config)).sub(/\A---\n/, "")
+            end
+
+            def canonicalize_config(config)
+              config = config.dup
+              config.delete("_source_file")
+
+              ordered = {}
+              preferred_order = %w[
+                name
+                last_synced
+                class
+                gem
+                models_dev_id
+                models
+                limits
+                aliases
+                api_key
+                capabilities
+                default_options
+                backends
+                endpoint
+                version
+              ]
+
+              preferred_order.each do |key|
+                ordered[key] = config.delete(key) if config.key?(key)
               end
 
-              # If field not found, add it after the name or first line
-              unless field_found
-                insert_index = 0
-                result.each_with_index do |line, idx|
-                  if /^name:/.match?(line)
-                    insert_index = idx + 1
-                    break
-                  end
-                end
-                # If no name field, add after first non-comment, non-blank line
-                if insert_index == 0
-                  result.each_with_index do |line, idx|
-                    next if line.strip.empty? || line.strip.start_with?("#") || line.strip.start_with?("---")
-
-                    insert_index = idx + 1
-                    break
-                  end
-                end
-                result.insert(insert_index, "#{field_name}: #{value}\n")
+              config.each do |key, value|
+                ordered[key] = value
               end
 
-              result.join
+              ordered
             end
           end
         end

data/lib/ace/support/models/molecules/provider_sync_diff.rb

@@ -81,11 +81,11 @@ module Ace
 
             # Build a mapping of canonical names to original names for current models
             # This handles cases like "model:nitro" -> "model"
-            current_canonical_to_original = {}
+            current_lookup = Set.new
             current_models.each do |model_id|
+              current_lookup << model_id
               canonical = Atoms::ModelNameCanonicalizer.canonicalize(model_id, provider: provider_name)
-              current_canonical_to_original[canonical] ||= []
-              current_canonical_to_original[canonical] << model_id
+              current_lookup << canonical
             end
 
             added = []
@@ -98,7 +98,7 @@ module Ace
             # Use canonical names for matching
             models_dev_models.each do |model_id, model_data|
               # Check if any current model (or its canonical form) matches this models.dev model
-              has_match = current_canonical_to_original.key?(model_id)
+              has_match = current_lookup.include?(model_id)
 
               if has_match
                 if model_data[:status] == "deprecated"
@@ -126,11 +126,16 @@ module Ace
             # Use canonical names to avoid false positives for suffixed models
             current_models.each do |model_id|
               canonical = Atoms::ModelNameCanonicalizer.canonicalize(model_id, provider: provider_name)
-              unless models_dev_canonical.include?(canonical)
+              unless models_dev_canonical.include?(model_id) || models_dev_canonical.include?(canonical)
                 removed << model_id
               end
             end
 
+            desired_models = (current_models.to_a + added - removed).uniq.sort
+            desired_limits = build_desired_limits(desired_models, models_dev_models, provider_name: provider_name)
+            current_limits = Atoms::ProviderConfigReader.extract_limits(config)
+            limits_changed = current_limits != desired_limits
+
             {
               status: :ok,
               added: added.sort,
@@ -138,6 +143,8 @@ module Ace
               removed: removed.sort,
               unchanged: unchanged.sort,
               deprecated: deprecated.sort,
+              desired_limits: desired_limits,
+              limits_changed: limits_changed,
               models_dev_count: models_dev_models.size,
               current_count: current_models.size,
               filtered_by_date: !since_date.nil?
@@ -152,6 +159,7 @@ module Ace
             total_removed = 0
             total_unchanged = 0
             total_deprecated = 0
+            total_limit_updates = 0
             providers_synced = 0
             providers_skipped = 0
 
@@ -162,6 +170,7 @@ module Ace
                 total_removed += result[:removed].size
                 total_unchanged += result[:unchanged].size
                 total_deprecated += result[:deprecated].size
+                total_limit_updates += 1 if result[:limits_changed]
               else
                 providers_skipped += 1
               end
@@ -172,6 +181,7 @@ module Ace
               removed: total_removed,
               unchanged: total_unchanged,
               deprecated: total_deprecated,
+              limit_updates: total_limit_updates,
               providers_synced: providers_synced,
               providers_skipped: providers_skipped
             }
@@ -184,7 +194,7 @@ module Ace
             results.any? do |_provider, result|
               next false unless result[:status] == :ok
 
-              result[:added].any? || result[:removed].any?
+              result[:added].any? || result[:removed].any? || result[:limits_changed]
             end
           end
 
@@ -223,10 +233,13 @@ module Ace
 
             models.each do |model_id, model_data|
               release_date = parse_date(model_data["release_date"])
+              limit = model_data["limit"] || {}
               result[model_id] = {
                 status: model_data["status"],
                 name: model_data["name"] || model_id,
-                release_date: release_date
+                release_date: release_date,
+                context_limit: limit["context"],
+                output_limit: limit["output"]
               }
             end
 
@@ -256,6 +269,63 @@ module Ace
             Atoms::ProviderConfigReader.extract_last_synced(config)
           end
 
+          def build_desired_limits(models, models_dev_models, provider_name:)
+            limit_entries = models.each_with_object({}) do |model_id, acc|
+              entry = extract_limit_entry(model_id, models_dev_models, provider_name: provider_name)
+              acc[model_id] = entry if entry.any?
+            end
+
+            return {} if limit_entries.empty?
+
+            default_pair = select_default_limit_pair(limit_entries.values)
+            default_limits = {}
+            unless default_pair.nil?
+              default_limits["context"] = default_pair[0]
+              default_limits["output"] = default_pair[1]
+            end
+
+            overrides = limit_entries.each_with_object({}) do |(model_id, entry), acc|
+              override = entry.dup
+              override.delete("context") if default_limits["context"] && override["context"] == default_limits["context"]
+              override.delete("output") if default_limits["output"] && override["output"] == default_limits["output"]
+              acc[model_id] = override if override.any?
+            end
+
+            desired = {}
+            desired["default"] = default_limits if default_limits.any?
+            desired["models"] = overrides.sort.to_h if overrides.any?
+            desired
+          end
+
+          def select_default_limit_pair(entries)
+            counts = Hash.new(0)
+
+            entries.each do |entry|
+              context = entry["context"]
+              output = entry["output"]
+              next if context.nil? || output.nil?
+
+              counts[[context, output]] += 1
+            end
+
+            counts.max_by { |(context, output), count| [count, context, output] }&.first
+          end
+
+          def extract_limit_entry(model_id, models_dev_models, provider_name:)
+            model_data = lookup_model_data(model_id, models_dev_models, provider_name: provider_name)
+            return {} unless model_data
+
+            entry = {}
+            entry["context"] = model_data[:context_limit] unless model_data[:context_limit].nil?
+            entry["output"] = model_data[:output_limit] unless model_data[:output_limit].nil?
+            entry
+          end
+
+          def lookup_model_data(model_id, models_dev_models, provider_name:)
+            models_dev_models[model_id] ||
+              models_dev_models[Atoms::ModelNameCanonicalizer.canonicalize(model_id, provider: provider_name)]
+          end
+
           def suggest_models_dev_id(models_dev_data, provider_name)
             # Try to find a provider that might match
             provider_lower = provider_name.downcase

data/lib/ace/support/models/organisms/provider_sync_orchestrator.rb

@@ -108,11 +108,15 @@ module Ace
             lines << "Summary: #{summary[:added]} added, #{summary[:removed]} removed, " \
                      "#{summary[:unchanged]} unchanged across #{summary[:providers_synced]} providers"
 
-            if summary[:deprecated] > 0
+            if summary[:deprecated].to_i > 0
               lines << "  (#{summary[:deprecated]} deprecated models flagged)"
             end
 
-            if summary[:providers_skipped] > 0
+            if summary[:limit_updates].to_i > 0
+              lines << "  (#{summary[:limit_updates]} provider limit configs need updates)"
+            end
+
+            if summary[:providers_skipped].to_i > 0
               lines << "  (#{summary[:providers_skipped]} providers not found in models.dev)"
             end
 
@@ -171,7 +175,7 @@ module Ace
 
             diff_results.each do |provider_name, diff|
               next unless diff[:status] == :ok
-              next if diff[:added].empty? && diff[:removed].empty?
+              next if diff[:added].empty? && diff[:removed].empty? && !diff[:limits_changed]
 
               begin
                 config = current_configs[provider_name]
@@ -191,7 +195,11 @@ module Ace
                 Atoms::ProviderConfigWriter.backup(source_file)
 
                 # Update file with models and last_synced date
-                Atoms::ProviderConfigWriter.update_models_and_sync_date(source_file, new_models)
+                Atoms::ProviderConfigWriter.update_models_and_sync_date(
+                  source_file,
+                  new_models,
+                  limits: diff[:desired_limits]
+                )
                 output.puts "Updated: #{source_file}"
               rescue ConfigError => e
                 errors << "#{provider_name}: #{e.message}"
@@ -238,7 +246,7 @@ module Ace
               return lines.join("\n")
             end
 
-            if diff[:added].empty? && diff[:removed].empty? && diff[:deprecated].empty?
+            if diff[:added].empty? && diff[:removed].empty? && diff[:deprecated].empty? && !diff[:limits_changed]
               lines << "  = (no changes)"
               if diff[:last_synced]
                 lines << "  Last synced: #{diff[:last_synced]}"
@@ -259,6 +267,21 @@ module Ace
               lines << "  - #{model.ljust(35)} (removed)"
             end
 
+            if diff[:limits_changed]
+              default_limits = diff.dig(:desired_limits, "default") || {}
+              default_parts = []
+              default_parts << "context=#{format_number(default_limits["context"])}" if default_limits["context"]
+              default_parts << "output=#{format_number(default_limits["output"])}" if default_limits["output"]
+              unless default_parts.empty?
+                lines << "  ~ default limits -> #{default_parts.join(', ')}"
+              end
+
+              override_models = diff.dig(:desired_limits, "models")&.keys || []
+              unless override_models.empty?
+                lines << "  ~ per-model limit overrides: #{override_models.join(', ')}"
+              end
+            end
+
             diff[:deprecated].each do |model|
               lines << "  ! #{model.ljust(35)} (deprecated)"
             end
@@ -271,6 +294,10 @@ module Ace
 
             lines.join("\n")
           end
+
+          def format_number(value)
+            value.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')
+          end
         end
       end
     end

data/lib/ace/support/models/version.rb

@@ -3,7 +3,7 @@
 module Ace
   module Support
     module Models
-      VERSION = "0.11.2"
+      VERSION = "0.12.0"
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-support-models
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.12.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-04-20 00:00:00.000000000 Z
+date: 2026-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-core