ace-support-models 0.9.3 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff2cc8a12292d741e29e06dcc42ff22ded276d09e4f4cbb49e653f59870b1e31
-  data.tar.gz: c712f8e10724dff4d283f19da754fd4ae4dbc935a4b3fd19adc243556343f575
+  metadata.gz: 90738d0888e9e24b0a22f0febc4cd012472e31598e63f2f6dedcb59111966571
+  data.tar.gz: 391d5d2e24473b8e9377603c9ab33f42500397de98616d02ba530117a991787e
 SHA512:
-  metadata.gz: 747e10e8bd1dc636c7e52074cba9d34ada6e9222322f0b1106e093c6d077002ea148112199328e24d03dc088a51b21592905f3a972b275a64c5be71922ac4884
-  data.tar.gz: a5574cafd0bc4e33d5fec6434f4fa9b302147515b59a9599743989edd6092dd4a823d92d395c52d8e2865d18ddaa69ef8946aad1bac58d2cf9e84111604d71a2
+  metadata.gz: b0c49eaebca896bf7f5ec8a522b952e187a4c9031efeb839036d01fb3505857d8522aef74ebb9bd20596b526547c967750ccfeaa5bec01b39e598e570feb2a04
+  data.tar.gz: 80a8dc203bfa7f0159b9d3056a9c7d0d6ac412a3b57a85f9b361cd5bf4dee161f014f2ff5878d73485018ab235557d0d36d9d6b8e563eb03e933b66ce3f1ce63

data/CHANGELOG.md

@@ -7,6 +7,56 @@ 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
+- Normalized sync stats calculation for partial and string-keyed provider payloads so `ace-models sync` and `ace-models status` no longer raise when cache/provider entries omit structured model hashes.
+
+## [0.11.1] - 2026-04-16
+
+### Fixed
+- Updated smoke scenario setup to source `mise.toml` from `ACE_E2E_SOURCE_ROOT` inside sandboxed runs and relaxed diff verification to accept the current public diff summary vocabulary.
+
+## [0.11.0] - 2026-04-15
+
+### Changed
+- Reworked `TS-MODELS-001` E2E to public-surface goal contracts by replacing cache hand-seeding with public `ace-models sync` setup, simplifying invalid-filter coverage, and adding cache status/diff goal cases.
+- Added deterministic fixture-driven sync support via `ACE_MODELS_FIXTURE_JSON` / `ACE_MODELS_API_URL` to keep cache-dependent provider E2E flows reproducible without hidden cache-shape recipes.
+
+### Fixed
+- Aligned cache-missing guidance to the flat command surface (`ace-models sync`) across provider/cache CLI errors and executable migration hints.
+
+## [0.10.2] - 2026-04-13
+
+### Fixed
+- **ace-support-models v0.10.2**: Normalized API cache provider and model payloads at read time (including string-array model lists), fixing `ace-llm-providers list`/`show` output from cached responses.
+
+## [0.10.1] - 2026-04-13
+
+### Changed
+- Completed the batch i05 migration follow-through for this package and aligned it with the restarted `fast` / `feat` / `e2e` verification model.
+
+### Technical
+- Included in the coordinated assignment-driven patch release for batch i05 package updates.
+
+
+### Changed
+- Migrated package tests to the restarted `fast` / `feat` / `e2e` model by moving deterministic coverage to `test/fast`, relocating legacy integration coverage to `test/feat`, and retaining workflow-value E2E scenario coverage.
+- Updated package README testing guidance and E2E scenario decision metadata to reflect the `fast` / `feat` / `e2e` contract.
+
 ## [0.9.3] - 2026-03-29
 
 ### Technical

data/README.md

@@ -34,6 +34,27 @@ ace-models sync                       # Update cache from models.dev
 ace-llm-providers list                # List known providers
 ```
 
+## Testing
+
+Use the package test lanes directly:
+
+```bash
+ace-test ace-support-models           # fast lane default
+ace-test ace-support-models feat      # feature-contract lane
+ace-test ace-support-models all       # all deterministic lanes
+ace-test-e2e ace-support-models       # retained workflow scenarios
+```
+
+For deterministic E2E setup of cache-dependent provider commands, use the public
+`ace-models sync` path with a fixture payload:
+
+```bash
+export ACE_MODELS_FIXTURE_JSON='{"anthropic":{"models":{"claude-sonnet-4":{"id":"claude-sonnet-4"}}}}'
+ace-models sync
+ace-llm-providers list
+unset ACE_MODELS_FIXTURE_JSON
+```
+
 ---
 
 Part of [ACE](https://github.com/cs3b/ace)

data/exe/ace-models

@@ -8,7 +8,7 @@ require_relative "../lib/ace/support/models/cli"
 old_cache_path = File.join(Dir.home, ".cache", "ace-llm-models-dev")
 if Dir.exist?(old_cache_path)
   warn "Note: Old cache detected at ~/.cache/ace-llm-models-dev"
-  warn "Run: ace-models sync && rm -rf ~/.cache/ace-llm-models-dev"
+  warn "Run: ace-models sync then rm -rf ~/.cache/ace-llm-models-dev"
 end
 
 # No args → show help

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

@@ -10,6 +10,8 @@ module Ace
         # Fetches data from the models.dev API using Faraday (ADR-010 compliant)
         class ApiFetcher
           API_URL = "https://models.dev/api.json"
+          FIXTURE_JSON_ENV = "ACE_MODELS_FIXTURE_JSON"
+          API_URL_ENV = "ACE_MODELS_API_URL"
           TIMEOUT = 30
           OPEN_TIMEOUT = 10
           MAX_RETRIES = 2
@@ -21,8 +23,12 @@ module Ace
             # @return [String] Raw JSON response
             # @raise [NetworkError] on network failures
             # @raise [ApiError] on non-200 responses
-            def fetch(url = API_URL)
-              response = connection.get(url)
+            def fetch(url = nil)
+              fixture_json = ENV[FIXTURE_JSON_ENV]
+              return fixture_json unless fixture_json.to_s.strip.empty?
+
+              resolved_url = url || ENV[API_URL_ENV] || API_URL
+              response = connection.get(resolved_url)
 
               unless response.success?
                 raise ApiError.new(

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/cli/commands/cache/status.rb

@@ -25,7 +25,7 @@ module Ace
                 end
 
                 unless status_data[:cached]
-                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models cache sync' first.")
+                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models sync' first.")
                 end
 
                 puts "Cache Status:"

data/lib/ace/support/models/cli/commands/providers/list.rb

@@ -20,7 +20,7 @@ module Ace
                 cache_manager = Molecules::CacheManager.new
 
                 unless cache_manager.cached?
-                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models cache sync' first.")
+                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models sync' first.")
                 end
 
                 providers = cache_manager.list_providers

data/lib/ace/support/models/cli/commands/providers/show.rb

@@ -21,7 +21,7 @@ module Ace
                 cache_manager = Molecules::CacheManager.new
 
                 unless cache_manager.cached?
-                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models cache sync' first.")
+                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models sync' first.")
                 end
 
                 provider_data = cache_manager.get_provider(provider_id)

data/lib/ace/support/models/cli/commands/providers/sync.rb

@@ -53,7 +53,7 @@ module Ace
                   puts orchestrator.format_result(result)
                 end
               rescue CacheError => e
-                raise Ace::Support::Cli::Error.new("#{e.message}. Run 'ace-models cache sync' first to download model data.")
+                raise Ace::Support::Cli::Error.new("#{e.message}. Run 'ace-models sync' first to download model data.")
               rescue ConfigError => e
                 raise Ace::Support::Cli::Error.new("Config error: #{e.message}")
               end

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

@@ -26,7 +26,8 @@ module Ace
             content = Atoms::FileReader.read(api_cache_path)
             return nil unless content
 
-            Atoms::JsonParser.parse(content)
+            data = Atoms::JsonParser.parse(content)
+            normalize_cache_data(data)
           end
 
           # Read previous API cache (for diff)
@@ -35,7 +36,8 @@ module Ace
             content = Atoms::FileReader.read(previous_cache_path)
             return nil unless content
 
-            Atoms::JsonParser.parse(content)
+            data = Atoms::JsonParser.parse(content)
+            normalize_cache_data(data)
           end
 
           # Write API data to cache
@@ -197,6 +199,17 @@ module Ace
             data
           end
 
+          def normalize_cache_data(data)
+            normalized = normalize_providers(data)
+            normalized.each_value do |provider_data|
+              next unless provider_data.is_a?(Hash)
+
+              provider_data["models"] = normalize_models(provider_data)
+            end
+
+            normalized
+          end
+
           def normalize_provider_collection(providers)
             case providers
             when Hash
@@ -205,7 +218,7 @@ module Ace
               providers.each_with_object({}) do |provider, acc|
                 next unless provider.is_a?(Hash)
 
-                provider_id = provider["id"]
+                provider_id = provider["id"] || provider[:id] || provider["provider_id"]
                 acc[provider_id] = provider if provider_id
               end
             else
@@ -221,10 +234,18 @@ module Ace
               models
             when Array
               models.each_with_object({}) do |model, acc|
-                next unless model.is_a?(Hash)
-
-                model_id = model["id"]
-                acc[model_id] = model if model_id
+                next unless model
+
+                case model
+                when Hash
+                  model_id = model["id"] || model[:id]
+                  acc[model_id] = model if model_id
+                when String
+                  acc[model] = {"id" => model, "name" => model}
+                when Symbol
+                  model_id = model.to_s
+                  acc[model_id] = {"id" => model_id, "name" => model_id}
+                end
               end
             else
               {}

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/organisms/sync_orchestrator.rb

@@ -90,7 +90,8 @@ module Ace
             models_by_provider = {}
 
             data.each do |provider_id, provider_data|
-              count = (provider_data["models"] || {}).size
+              models = provider_models(provider_data)
+              count = models.size
               models_by_provider[provider_id] = count
               model_count += count
             end
@@ -101,6 +102,13 @@ module Ace
               top_providers: models_by_provider.sort_by { |_, v| -v }.first(10).to_h
             }
           end
+
+          def provider_models(provider_data)
+            return {} unless provider_data.is_a?(Hash)
+
+            models = provider_data["models"] || provider_data[:models]
+            models.is_a?(Hash) ? models : {}
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module Ace
   module Support
     module Models
-      VERSION = '0.9.3'
+      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.9.3
+  version: 0.12.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-03-29 00:00:00.000000000 Z
+date: 2026-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-core