ace-llm 0.32.1 → 0.38.2

data/lib/ace/llm/atoms/provider_config_validator.rb

@@ -11,6 +11,7 @@ module Ace
         # Optional fields with expected types
         OPTIONAL_FIELDS = {
           "models" => Array,
+          "limits" => Hash,
           "api_key" => [Hash, NilClass],
           "capabilities" => Array,
           "default_options" => Hash,
@@ -69,6 +70,7 @@ module Ace
           validate_class(config["class"], errors) if config["class"]
           validate_gem(config["gem"], errors) if config["gem"]
           validate_models(config["models"], warnings) if config["models"]
+          validate_limits(config["limits"], errors, warnings) if config["limits"]
           validate_api_key(config["api_key"], errors, warnings) if config["api_key"]
           validate_capabilities(config["capabilities"], warnings) if config["capabilities"]
           validate_default_options(config["default_options"], warnings) if config["default_options"]
@@ -147,6 +149,57 @@ module Ace
           end
         end
 
+        def validate_limits(limits, errors, warnings)
+          unless limits.is_a?(Hash)
+            errors << "Limits must be a Hash, got #{limits.class}"
+            return
+          end
+
+          valid_limit_keys = %w[default models]
+          unknown_limit_keys = limits.keys - valid_limit_keys
+          unless unknown_limit_keys.empty?
+            warnings << "Unknown limits keys: #{unknown_limit_keys.join(", ")}"
+          end
+
+          validate_limit_entry(limits["default"], "limits.default", errors) if limits["default"]
+
+          return unless limits["models"]
+
+          unless limits["models"].is_a?(Hash)
+            errors << "limits.models must be a Hash, got #{limits["models"].class}"
+            return
+          end
+
+          limits["models"].each do |model_name, entry|
+            if model_name.to_s.strip.empty?
+              errors << "limits.models entries must have non-empty model names"
+              next
+            end
+
+            validate_limit_entry(entry, "limits.models.#{model_name}", errors)
+          end
+        end
+
+        def validate_limit_entry(entry, path, errors)
+          unless entry.is_a?(Hash)
+            errors << "#{path} must be a Hash, got #{entry.class}"
+            return
+          end
+
+          valid_keys = %w[context output]
+          unknown_keys = entry.keys - valid_keys
+          unless unknown_keys.empty?
+            errors << "#{path} contains unknown keys: #{unknown_keys.join(", ")}"
+          end
+
+          entry.each do |field, value|
+            next unless valid_keys.include?(field)
+            next if value.is_a?(Integer) && value >= 0
+
+            errors << "#{path}.#{field} must be a non-negative Integer"
+          end
+        end
+
         # Validate API key configuration
         def validate_api_key(api_key_config, errors, warnings)
           if api_key_config.is_a?(Hash)

data/lib/ace/llm/cli/commands/query.rb

@@ -32,6 +32,9 @@ module Ace
           option :model, type: :string, desc: "Model name (overrides PROVIDER[:MODEL])"
           option :prompt, type: :string, desc: "Prompt text (overrides positional PROMPT)"
           option :force, type: :boolean, default: false, desc: "Force overwrite existing files"
+          option :interactive, type: :boolean, default: false, desc: "Start an interactive CLI session instead of one-shot query"
+          option :fallback, type: :boolean, default: true, desc: "Use provider fallback for this query"
+          option :json, type: :boolean, default: false, desc: "Output command results as JSON"
 
           option :version, type: :boolean, desc: "Show version information"
           option :list_providers, type: :boolean, desc: "List available LLM providers"
@@ -54,6 +57,7 @@ module Ace
             end
 
             @prompt = options[:prompt] || prompt_text
+            options[:format] ||= "json" if options[:json]
 
             return show_help if @provider_model.nil? && @prompt.nil?
             return show_provider_help if @prompt.nil? || @prompt.empty?
@@ -88,6 +92,9 @@ module Ace
             puts "      --timeout SECONDS          Request timeout in seconds"
             puts "      --model MODEL              Model name (overrides PROVIDER[:MODEL])"
             puts "      --prompt PROMPT            Prompt text (overrides positional PROMPT)"
+            puts "      --interactive              Start an interactive CLI session"
+            puts "      --no-fallback              Disable provider fallback for this query"
+            puts "      --json                     Output command results as JSON"
             puts "      --force                    Force overwrite existing files"
             puts "  -q, --quiet                    Suppress config summary output"
             puts "  -d, --debug                    Enable debug output"
@@ -97,17 +104,20 @@ module Ace
             puts '  ace-llm google:gemini-2.5-flash "What is Ruby?"'
             puts '  ace-llm gflash "Quick question" # using alias'
             puts '  ace-llm gflash@ro "Summarize this diff"'
-            puts '  ace-llm codex:gpt-5:high@ro "Review this code"'
+            puts '  ace-llm codex:gpt:high@ro "Review this code"'
             puts '  ace-llm claude:sonnet "Summarize this diff" --preset rw'
             puts '  ace-llm claude:sonnet "Hi" --cli-args "dangerously-skip-permissions"'
             puts '  ace-llm claude:sonnet "Hi" --cli-args "--model=claude-sonnet-4-0 --verbose"'
+            puts '  ace-llm codex:gpt@yolo "/as-assign-drive abc123@010" --interactive'
+            puts '  ace-llm gemini:pro "ping" --no-fallback --timeout 15 --max-tokens 4'
             puts ""
             puts "Provider Aliases:"
             puts "  Short aliases for common provider:MODEL combinations:"
-            puts "    gflash    → google:gemini-2.5-flash"
-            puts "    glite     → google:gemini-2.0-flash-lite"
-            puts "    gpt4      → openai:gpt-4"
-            puts "    claude    → anthropic:claude-3-5-sonnet"
+            puts "    gflash    → google:gemini-flash-latest"
+            puts "    glite     → google:gemini-flash-lite-latest"
+            puts "    codex:gpt → codex:gpt-5.4"
+            puts "    cc        → claude:sonnet"
+            puts "    sonnet    → anthropic:claude-sonnet-4-5"
           end
 
           def show_provider_help
@@ -132,7 +142,7 @@ module Ace
             return if quiet?(options)
 
             require "ace/core"
-            summary_keys = %w[provider_model preset temperature max_tokens format timeout system_append cli_args]
+            summary_keys = %w[provider_model preset temperature max_tokens format timeout system_append cli_args fallback]
             Ace::Core::Atoms::ConfigSummary.display(
               command: "query",
               config: options.merge(provider_model: @provider_model),
@@ -150,6 +160,23 @@ module Ace
             system_append_text = options[:system_append] ? file_handler.read_content(options[:system_append]) : nil
             normalized_timeout = normalize_timeout(options[:timeout])
 
+            if options[:interactive]
+              validate_interactive_options!(options)
+              invocation = Ace::LLM::Molecules::InteractiveCommandBuilder.new.build(
+                provider_model: @provider_model,
+                prompt: prompt_text,
+                system: system_text,
+                cli_args: options[:cli_args],
+                system_append: system_append_text,
+                preset: options[:preset],
+                model: (@model_from_option ? nil : options[:model]),
+                working_dir: Dir.pwd,
+                subprocess_env: ENV.to_h
+              )
+              execute_interactive_invocation(invocation)
+              return
+            end
+
             resolved_model_override = @model_from_option ? nil : options[:model]
             response = Ace::LLM::QueryInterface.query(
               @provider_model,
@@ -162,7 +189,8 @@ module Ace
               model: resolved_model_override,
               cli_args: options[:cli_args],
               system_append: system_append_text,
-              preset: options[:preset]
+              preset: options[:preset],
+              fallback: (options[:fallback] == false ? false : nil)
             )
 
             output_response(response, options)
@@ -178,6 +206,27 @@ module Ace
             raise
           end
 
+          def validate_interactive_options!(options)
+            conflicts = []
+            conflicts << "--output" if options[:output]
+            conflicts << "--force" if options[:force]
+            conflicts << "--temperature" unless options[:temperature].nil?
+            conflicts << "--max-tokens" unless options[:max_tokens].nil?
+            explicit_format = options[:format]
+            conflicts << "--format" if explicit_format && explicit_format != "text"
+            conflicts << "--no-fallback" if options[:fallback] == false
+            return if conflicts.empty?
+
+            raise Ace::Support::Cli::Error, "Interactive mode does not support #{conflicts.join(', ')}"
+          end
+
+          def execute_interactive_invocation(invocation)
+            env = invocation[:env].respond_to?(:to_h) ? invocation[:env].to_h : {}
+            command = invocation[:command]
+            working_dir = invocation[:working_dir]
+            Kernel.exec(env, *command, chdir: working_dir)
+          end
+
           def output_response(response, options)
             format = options[:format] || "text"
             handler = Ace::LLM::Molecules::FormatHandlers.get_handler(format)

data/lib/ace/llm/molecules/client_registry.rb

@@ -142,7 +142,8 @@ module Ace
           provider = get_provider(provider_name)
           return false unless provider
 
-          api_key_present?(provider["api_key"])
+          normalized_name = normalize_provider_name(provider["name"] || provider_name)
+          credential_status(provider, normalized_name)[:present]
         end
 
         # Reload all configurations

data/lib/ace/llm/molecules/fallback_orchestrator.rb

@@ -2,6 +2,7 @@
 
 require_relative "../atoms/error_classifier"
 require_relative "../models/fallback_config"
+require_relative "provider_model_parser"
 
 module Ace
   module LLM
@@ -35,10 +36,12 @@ module Ace
           @visited_providers.clear
 
           # If fallback disabled, just execute with primary
-          return yield get_client(primary_provider, registry) if @config.disabled?
+          return yield(get_client(primary_provider, registry), primary_provider) if @config.disabled?
 
           # Try primary provider with retries
-          result = try_provider_with_retry(primary_provider, registry) { |client| yield client }
+          result = try_provider_with_retry(primary_provider, registry) do |client, provider_name|
+            yield client, provider_name
+          end
           return result if result
 
           # Try fallback providers in order (per-provider chain or default)
@@ -54,7 +57,9 @@ module Ace
 
             report_status("ℹ Trying fallback provider #{fallback_provider}...")
 
-            result = try_provider_with_retry(fallback_provider, registry) { |client| yield client }
+            result = try_provider_with_retry(fallback_provider, registry) do |client, provider_name|
+              yield client, provider_name
+            end
             return result if result
           end
 
@@ -77,7 +82,7 @@ module Ace
 
           loop do
             client = get_client(provider_name, registry)
-            return yield client
+            return yield client, provider_name
           rescue => error
             last_error = error
 
@@ -145,10 +150,11 @@ module Ace
           opts = {}
           opts[:timeout] = @timeout if @timeout
 
-          # Parse provider:model format if present
-          if provider_name.include?(":")
-            provider, model = provider_name.split(":", 2)
-            registry.get_client(provider, model: model, **opts)
+          parser = ProviderModelParser.new(registry: registry)
+          parsed = parser.parse(provider_name.to_s)
+
+          if parsed.valid?
+            registry.get_client(parsed.provider, model: parsed.model, **opts)
           else
             registry.get_client(provider_name, **opts)
           end

data/lib/ace/llm/molecules/interactive_command_builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Ace
+  module LLM
+    module Molecules
+      class InteractiveCommandBuilder
+        def initialize(registry: ClientRegistry.new)
+          @registry = registry
+          @parser = ProviderModelParser.new(registry: registry)
+        end
+
+        def build(provider_model:, prompt:, model: nil, preset: nil, system: nil, cli_args: nil,
+          system_append: nil, sandbox: nil, working_dir: nil, subprocess_env: nil)
+          parse_result = @parser.parse(provider_model)
+          raise Error, parse_result.error unless parse_result.valid?
+
+          resolved_preset = QueryInterface.send(:resolve_preset_name, parse_result.preset, preset)
+          final_model = model || parse_result.model
+          if final_model.nil? || final_model.empty?
+            raise Error, "No model specified and no default available for #{parse_result.provider}"
+          end
+
+          final_prompt = prompt.to_s
+          raise Error, "No prompt specified. Use positional prompt or --prompt." if final_prompt.empty?
+
+        generation_opts = QueryInterface.send(
+            :build_generation_opts,
+            provider: parse_result.provider,
+            preset: resolved_preset,
+            thinking_level: parse_result.thinking_level,
+            temperature: nil,
+            max_tokens: nil,
+            system_file: nil,
+            prompt_file: nil,
+            cli_args: cli_args,
+            system_append: system_append,
+            sandbox: sandbox,
+            working_dir: working_dir,
+            subprocess_env: subprocess_env,
+            subprocess_command_prefix: nil,
+            last_message_file: nil
+          )
+
+          client = @registry.get_client(parse_result.provider, model: final_model)
+          unless client.respond_to?(:interactive_supported?) && client.interactive_supported?
+            raise Error, "Provider '#{parse_result.provider}' does not support interactive mode"
+          end
+
+          messages = []
+          messages << {role: "system", content: system} if system && !system.empty?
+          messages << {role: "user", content: final_prompt}
+
+          invocation = client.build_interactive_invocation(messages, **generation_opts)
+          invocation.merge(
+            provider: parse_result.provider,
+            model: final_model,
+            preset: resolved_preset,
+            thinking_level: parse_result.thinking_level
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ace/llm/molecules/model_limit_resolver.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "ace/support/models"
+require_relative "client_registry"
+require_relative "provider_model_parser"
+
+module Ace
+  module LLM
+    module Molecules
+      # Resolves model context/output limits against the expanded concrete target.
+      class ModelLimitResolver
+        DEFAULT_CONTEXT_LIMIT = 200_000
+
+        ResolveResult = Struct.new(
+          :provider,
+          :model,
+          :context_limit,
+          :output_limit,
+          :source,
+          :original_target,
+          keyword_init: true
+        ) do
+          def full_model
+            return nil if provider.to_s.empty? || model.to_s.empty?
+
+            "#{provider}:#{model}"
+          end
+        end
+
+        def self.resolve(target, **kwargs)
+          new(**kwargs).resolve(target)
+        end
+
+        def initialize(registry: nil, parser: nil)
+          @registry = registry || ClientRegistry.new
+          @parser = parser || ProviderModelParser.new(registry: @registry)
+        end
+
+        def resolve(target)
+          original_target = target.to_s
+          return fallback_result(original_target) if original_target.strip.empty?
+
+          parsed = @parser.parse(original_target)
+          return fallback_result(original_target) if parsed.invalid?
+
+          provider_config = @registry.get_provider(parsed.provider)
+          return fallback_result(original_target, provider: parsed.provider, model: parsed.model) unless provider_config
+
+          limits = Ace::Support::Models::Atoms::ProviderConfigReader.extract_limits(provider_config)
+          default_limits = limits["default"] || {}
+          model_limits = limits.dig("models", parsed.model) || {}
+          merged_limits = default_limits.merge(model_limits)
+
+          ResolveResult.new(
+            provider: parsed.provider,
+            model: parsed.model,
+            context_limit: merged_limits["context"] || DEFAULT_CONTEXT_LIMIT,
+            output_limit: merged_limits["output"],
+            source: limit_source(default_limits, model_limits),
+            original_target: original_target
+          )
+        rescue
+          fallback_result(original_target)
+        end
+
+        private
+
+        def limit_source(default_limits, model_limits)
+          return :model_override if model_limits.any?
+          return :provider_default if default_limits.any?
+
+          :fallback
+        end
+
+        def fallback_result(original_target, provider: nil, model: nil)
+          ResolveResult.new(
+            provider: provider,
+            model: model,
+            context_limit: DEFAULT_CONTEXT_LIMIT,
+            output_limit: nil,
+            source: :fallback,
+            original_target: original_target
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ace/llm/molecules/role_resolver.rb

@@ -60,7 +60,6 @@ module Ace
           return false if provider.nil? || provider.empty?
           return false if @configuration.provider_inactive?(provider)
           return false unless @registry.provider_available?(provider)
-          return false if @registry.provider_api_key_required?(provider) && !@registry.provider_api_key_present?(provider)
 
           true
         end

data/lib/ace/llm/query_interface.rb

@@ -35,6 +35,7 @@ module Ace
         sandbox: nil,
         working_dir: nil,
         subprocess_env: nil,
+        subprocess_command_prefix: nil,
         last_message_file: nil)
         registry = Molecules::ClientRegistry.new
         parser = Molecules::ProviderModelParser.new(registry: registry)
@@ -43,12 +44,6 @@ module Ace
         raise Error, parse_result.error unless parse_result.valid?
 
         resolved_preset = resolve_preset_name(parse_result.preset, preset)
-        execution_overrides = load_execution_overrides(
-          provider: parse_result.provider,
-          preset: resolved_preset,
-          thinking_level: parse_result.thinking_level
-        )
-
         final_model = model || parse_result.model
         if final_model.nil? || final_model.empty?
           raise Error, "No model specified and no default available for #{parse_result.provider}"
@@ -63,38 +58,41 @@ module Ace
         messages << {role: "system", content: system} if system && !system.empty?
         messages << {role: "user", content: final_prompt}
 
-        generation_opts = {}
-        resolved_temperature = first_non_nil(temperature, execution_overrides["temperature"])
-        resolved_max_tokens = first_non_nil(max_tokens, execution_overrides["max_tokens"])
-        resolved_cli_args = first_non_nil(cli_args, execution_overrides["cli_args"])
-        resolved_system_append = first_non_empty(system_append, execution_overrides["system_append"])
-        resolved_sandbox = first_non_nil(sandbox, execution_overrides["sandbox"])
-        resolved_working_dir = first_non_nil(working_dir, execution_overrides["working_dir"])
-        resolved_subprocess_env = merge_hash_values(execution_overrides["subprocess_env"], subprocess_env)
-
-        generation_opts[:temperature] = resolved_temperature unless resolved_temperature.nil?
-        generation_opts[:max_tokens] = resolved_max_tokens unless resolved_max_tokens.nil?
-        generation_opts[:system_file] = system_file if system_file
-        generation_opts[:prompt_file] = prompt_file if prompt_file
-        generation_opts[:cli_args] = resolved_cli_args unless blank_value?(resolved_cli_args)
-        generation_opts[:system_append] = resolved_system_append unless blank_value?(resolved_system_append)
-        generation_opts[:sandbox] = resolved_sandbox if resolved_sandbox
-        generation_opts[:working_dir] = resolved_working_dir unless blank_value?(resolved_working_dir)
-        generation_opts[:subprocess_env] = resolved_subprocess_env unless resolved_subprocess_env.nil?
-        generation_opts[:last_message_file] = last_message_file if last_message_file
+        generation_opts = build_generation_opts(
+          provider: parse_result.provider,
+          preset: resolved_preset,
+          thinking_level: parse_result.thinking_level,
+          temperature: temperature,
+          max_tokens: max_tokens,
+          system_file: system_file,
+          prompt_file: prompt_file,
+          cli_args: cli_args,
+          system_append: system_append,
+          sandbox: sandbox,
+          working_dir: working_dir,
+          subprocess_env: subprocess_env,
+          subprocess_command_prefix: subprocess_command_prefix,
+          last_message_file: last_message_file
+        )
+        execution_overrides = load_execution_overrides(
+          provider: parse_result.provider,
+          preset: resolved_preset,
+          thinking_level: parse_result.thinking_level
+        )
 
         if debug
           warn "Provider: #{parse_result.provider}"
           warn "Model: #{final_model}"
           warn "Preset: #{resolved_preset}" if resolved_preset
           warn "Thinking level: #{parse_result.thinking_level}" if parse_result.thinking_level
-          warn "Temperature: #{resolved_temperature}" unless resolved_temperature.nil?
-          warn "Max tokens: #{resolved_max_tokens}" unless resolved_max_tokens.nil?
+          warn "Temperature: #{generation_opts[:temperature]}" unless generation_opts[:temperature].nil?
+          warn "Max tokens: #{generation_opts[:max_tokens]}" unless generation_opts[:max_tokens].nil?
         end
 
         fallback_config = load_fallback_config(fallback, fallback_providers, parser: parser)
         timeout_value = first_non_nil(timeout, execution_overrides["timeout"], Molecules::ConfigLoader.get("llm.timeout"), 120)
         resolved_timeout = normalize_timeout(timeout_value)
+        parser_for_options = Molecules::ProviderModelParser.new(registry: registry)
 
         response = execute_with_fallback(
           provider: parse_result.provider,
@@ -105,7 +103,39 @@ module Ace
           fallback_config: fallback_config,
           timeout: resolved_timeout,
           debug: debug,
-          role_fallbacks: parse_result.role_fallbacks
+          role_fallbacks: parse_result.role_fallbacks,
+          preset: resolved_preset,
+          thinking_level: parse_result.thinking_level,
+          option_builder: lambda { |target_selector|
+            parsed_target = parser_for_options.parse(target_selector.to_s)
+            target_provider = parsed_target.valid? ? parsed_target.provider : parse_result.provider
+            target_preset = if parsed_target.valid? && parsed_target.preset
+              parsed_target.preset
+            else
+              resolved_preset
+            end
+            target_thinking = if parsed_target.valid?
+              parsed_target.thinking_level
+            else
+              parse_result.thinking_level
+            end
+            build_generation_opts(
+              provider: target_provider,
+              preset: target_preset,
+              thinking_level: target_thinking,
+              temperature: temperature,
+              max_tokens: max_tokens,
+              system_file: system_file,
+              prompt_file: prompt_file,
+              cli_args: cli_args,
+              system_append: system_append,
+              sandbox: sandbox,
+              working_dir: working_dir,
+              subprocess_env: subprocess_env,
+              subprocess_command_prefix: subprocess_command_prefix,
+              last_message_file: last_message_file
+            )
+          }
         )
 
         text_content = extract_text_content(response)
@@ -174,6 +204,43 @@ module Ace
       end
       private_class_method :load_execution_overrides
 
+      def self.build_generation_opts(provider:, preset:, thinking_level:, temperature:, max_tokens:, system_file:,
+        prompt_file:, cli_args:, system_append:, sandbox:, working_dir:, subprocess_env:, subprocess_command_prefix:,
+        last_message_file:)
+        execution_overrides = load_execution_overrides(
+          provider: provider,
+          preset: preset,
+          thinking_level: thinking_level
+        )
+
+        generation_opts = {}
+        resolved_temperature = first_non_nil(temperature, execution_overrides["temperature"])
+        resolved_max_tokens = first_non_nil(max_tokens, execution_overrides["max_tokens"])
+        resolved_cli_args = append_cli_args(execution_overrides["cli_args"], cli_args)
+        resolved_system_append = first_non_empty(system_append, execution_overrides["system_append"])
+        resolved_sandbox = first_non_nil(sandbox, execution_overrides["sandbox"])
+        resolved_working_dir = first_non_nil(working_dir, execution_overrides["working_dir"])
+        resolved_subprocess_env = merge_hash_values(execution_overrides["subprocess_env"], subprocess_env)
+        resolved_subprocess_command_prefix = first_non_nil(
+          subprocess_command_prefix,
+          execution_overrides["subprocess_command_prefix"]
+        )
+
+        generation_opts[:temperature] = resolved_temperature unless resolved_temperature.nil?
+        generation_opts[:max_tokens] = resolved_max_tokens unless resolved_max_tokens.nil?
+        generation_opts[:system_file] = system_file if system_file
+        generation_opts[:prompt_file] = prompt_file if prompt_file
+        generation_opts[:cli_args] = resolved_cli_args unless blank_value?(resolved_cli_args)
+        generation_opts[:system_append] = resolved_system_append unless blank_value?(resolved_system_append)
+        generation_opts[:sandbox] = resolved_sandbox if resolved_sandbox
+        generation_opts[:working_dir] = resolved_working_dir unless blank_value?(resolved_working_dir)
+        generation_opts[:subprocess_env] = resolved_subprocess_env unless resolved_subprocess_env.nil?
+        generation_opts[:subprocess_command_prefix] = resolved_subprocess_command_prefix unless blank_value?(resolved_subprocess_command_prefix)
+        generation_opts[:last_message_file] = last_message_file if last_message_file
+        generation_opts
+      end
+      private_class_method :build_generation_opts
+
       def self.merge_execution_overrides(base, overlay)
         left = base.respond_to?(:to_h) ? deep_stringify_keys(base.to_h) : deep_stringify_keys(base || {})
         right = overlay.respond_to?(:to_h) ? deep_stringify_keys(overlay.to_h) : deep_stringify_keys(overlay || {})
@@ -291,7 +358,7 @@ module Ace
       end
 
       def self.execute_with_fallback(provider:, model:, messages:, generation_opts:,
-        registry:, fallback_config:, timeout:, debug:, role_fallbacks: nil)
+        registry:, fallback_config:, timeout:, debug:, role_fallbacks: nil, preset: nil, thinking_level: nil, option_builder:)
         if fallback_config.disabled?
           client = registry.get_client(provider, model: model, timeout: timeout)
           return client.generate(messages, **generation_opts)
@@ -300,9 +367,10 @@ module Ace
         primary_provider_string = model ? "#{provider}:#{model}" : provider
 
         # Inject remaining role candidates ahead of the global fallback chain
+        normalized_role_fallbacks = normalize_fallback_providers(role_fallbacks, Molecules::ProviderModelParser.new(registry: registry))
         if role_fallbacks&.any?
           existing_chain = fallback_config.providers_for(primary_provider_string)
-          merged_chain = role_fallbacks + (existing_chain - role_fallbacks)
+          merged_chain = normalized_role_fallbacks + (existing_chain - normalized_role_fallbacks)
           fallback_config = fallback_config.merge(chains: {primary_provider_string => merged_chain})
         end
 
@@ -314,8 +382,13 @@ module Ace
           timeout: timeout
         )
 
-        orchestrator.execute(primary_provider: primary_provider_string, registry: registry) do |client|
-          client.generate(messages, **generation_opts)
+        orchestrator.execute(primary_provider: primary_provider_string, registry: registry) do |client, target_selector|
+          opts = if target_selector.to_s == primary_provider_string
+            generation_opts
+          else
+            option_builder.call(target_selector)
+          end
+          client.generate(messages, **opts)
         end
       end
 
@@ -380,7 +453,7 @@ module Ace
 
           parse_result = parser.parse(provider)
           canonical_provider = if parse_result.valid?
-            "#{parse_result.provider}:#{parse_result.model}"
+            parse_result.to_s
           else
             provider
           end

data/lib/ace/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module LLM
-    VERSION = '0.32.1'
+    VERSION = '0.38.2'
   end
 end

data/lib/ace/llm.rb

@@ -25,9 +25,11 @@ require_relative "llm/molecules/file_io_handler"
 require_relative "llm/molecules/llm_alias_resolver"
 require_relative "llm/molecules/role_resolver"
 require_relative "llm/molecules/provider_model_parser"
+require_relative "llm/molecules/model_limit_resolver"
 require_relative "llm/molecules/format_handlers"
 require_relative "llm/molecules/client_registry"
 require_relative "llm/molecules/fallback_orchestrator"
+require_relative "llm/molecules/interactive_command_builder"
 
 require_relative "llm/query_interface"