lex-llm-gemini 0.3.13 → 0.4.4

data/lib/legion/extensions/llm/gemini/actors/fleet_worker.rb

@@ -2,8 +2,8 @@
 
 begin
   require 'legion/extensions/actors/subscription'
-rescue LoadError => e
-  warn(e.message) if $VERBOSE
+rescue LoadError
+  nil
 end
 
 unless defined?(Legion::Extensions::Actors::Subscription)
@@ -11,6 +11,7 @@ unless defined?(Legion::Extensions::Actors::Subscription)
 end
 
 require 'legion/extensions/llm/gemini'
+require 'legion/extensions/llm/gemini/runners/fleet_worker'
 require 'legion/extensions/llm/fleet/provider_responder'
 
 module Legion
@@ -20,8 +21,11 @@ module Legion
         module Actor
           # Subscription actor for Gemini fleet request consumption.
           class FleetWorker < Legion::Extensions::Actors::Subscription
+            # The Subscription dispatch path (use_runner? == false) calls
+            # runner_class.send(fn, **message) — a String cannot be send-ed,
+            # so the runner must be the resolved module constant.
             def runner_class
-              'Legion::Extensions::Llm::Gemini::Runners::FleetWorker'
+              Legion::Extensions::Llm::Gemini::Runners::FleetWorker
             end
 
             def runner_function

data/lib/legion/extensions/llm/gemini/provider.rb

@@ -6,124 +6,26 @@ module Legion
   module Extensions
     module Llm
       module Gemini
-        # Gemini provider implementation for the Legion::Extensions::Llm base provider contract.
-        class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
-          include Legion::Logging::Helper
-
-          class << self
-            attr_writer :registry_publisher
-
-            def slug = 'gemini'
-            def configuration_options = %i[gemini_api_key gemini_api_base]
-            def configuration_requirements = %i[gemini_api_key]
-            def capabilities = Capabilities
-
-            def registry_publisher
-              @registry_publisher ||= Legion::Extensions::Llm::RegistryPublisher.new(provider_family: :gemini)
-            end
-          end
-
-          # Capability predicates for Gemini API models.
-          module Capabilities
-            module_function
-
-            def chat?(model) = supported?(model, 'generateContent')
-            def streaming?(model) = supported?(model, 'streamGenerateContent')
-            def embeddings?(model) = supported?(model, 'embedContent')
-            def vision?(model) = chat?(model) && model_id(model).match?(/gemini|flash|pro/)
-            def functions?(model) = chat?(model)
-
-            def critical_capabilities_for(model)
-              [
-                ('streaming' if streaming?(model)),
-                ('embeddings' if embeddings?(model)),
-                ('function_calling' if functions?(model)),
-                ('vision' if vision?(model))
-              ].compact
-            end
-
-            def supported?(model, action)
-              methods = generation_methods(model)
-              return model_id(model).include?('embedding') if action == 'embedContent' && methods.empty?
-              return true if methods.empty? && action != 'embedContent'
-
-              methods.include?(action)
-            end
-
-            def generation_methods(model)
-              metadata = metadata_for(model)
-              Array(metadata[:supported_generation_methods] || metadata['supported_generation_methods'] ||
-                    metadata['supportedGenerationMethods'])
-            end
-
-            def model_id(model)
-              return model.fetch('name', '').delete_prefix('models/') if model.is_a?(Hash)
-
-              model.respond_to?(:id) ? model.id.to_s : model.to_s
-            end
-
-            def metadata_for(model)
-              return model if model.is_a?(Hash)
-              return model.metadata if model.respond_to?(:metadata)
-
-              {}
-            end
-          end
-
-          def settings
-            Gemini.default_settings
-          end
-
-          def api_base
-            config.gemini_api_base || settings[:endpoint] || 'https://generativelanguage.googleapis.com/v1beta'
-          end
-
-          def headers
-            identity_headers.merge('x-goog-api-key' => config.gemini_api_key)
-          end
-
-          def completion_url = generate_content_url(model: @model)
-          def stream_url = stream_generate_content_url(model: @model)
-          def models_url = 'models'
-          def embedding_url(model:) = embed_content_url(model:)
-
-          def generate_content_url(model:)
-            "#{model_path(model)}:generateContent"
-          end
-
-          def stream_generate_content_url(model:)
-            "#{model_path(model)}:streamGenerateContent?alt=sse"
-          end
-
-          def embed_content_url(model:)
-            "#{model_path(model)}:embedContent"
-          end
-
-          def list_models(**)
-            log.info { 'listing available Gemini models' }
-            super.tap do |models|
-              log.info { "discovered #{models.size} Gemini model(s); publishing to registry" }
-              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
-            end
-          end
-
+        # Message formatting helpers mixed into Provider.
+        module MessageFormatter
           private
 
-          def model_path(model)
-            value = model.respond_to?(:id) ? model.id : model.to_s
-            value.start_with?('models/') ? value : "models/#{value}"
+          def render_payload(messages, **opts)
+            model       = opts.fetch(:model)
+            tools       = opts.fetch(:tools)
+            temperature = opts.fetch(:temperature)
+            @model      = model.id
+            build_request_payload(messages: messages, tools: tools, temperature: temperature,
+                                  schema: opts[:schema], tool_prefs: opts[:tool_prefs])
           end
 
-          # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
-          def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:)
-            @model = model.id
+          def build_request_payload(messages:, tools:, temperature:, schema:, tool_prefs:)
             payload = { contents: format_messages(messages), generationConfig: generation_config(temperature, schema) }
             payload[:systemInstruction] = system_instruction(messages)
             payload[:tools] = format_tools(tools) unless tools.empty?
             payload[:toolConfig] = tool_config(tool_prefs) if tool_prefs
             payload.compact
           end
-          # rubocop:enable Metrics/ParameterLists,Lint/UnusedMethodArgument
 
           def generation_config(temperature, schema)
             {
@@ -187,7 +89,6 @@ module Legion
           end
 
           def tool_call_parts(message)
-            # Array is canonical (name-keyed hashes dropped parallel same-name calls)
             calls = message.tool_calls.is_a?(Hash) ? message.tool_calls.values : Array(message.tool_calls)
             calls.map do |tool_call|
               { functionCall: { name: tool_call.name, args: tool_call.arguments } }
@@ -223,6 +124,16 @@ module Legion
             { functionCallingConfig: { mode: choice.to_s } }
           end
 
+          def model_path(model)
+            value = model.respond_to?(:id) ? model.id : model.to_s
+            value.start_with?('models/') ? value : "models/#{value}"
+          end
+        end
+
+        # Response parsing helpers mixed into Provider.
+        module ResponseParser
+          private
+
           def parse_completion_response(response)
             body = response.body
             parts = response_parts(body)
@@ -312,7 +223,27 @@ module Legion
             end
           end
 
-          # -- policy resolution requires many sources
+          def render_embedding_payload(text, model:, dimensions:)
+            {
+              model: model_path(model),
+              content: { parts: [{ text: text.to_s }] },
+              outputDimensionality: dimensions
+            }.compact
+          end
+
+          def parse_embedding_response(response, model:, **)
+            Legion::Extensions::Llm::Embedding.new(
+              vectors: response.body.dig('embedding', 'values'),
+              model: model,
+              input_tokens: response.body.dig('usageMetadata', 'promptTokenCount').to_i
+            )
+          end
+        end
+
+        # Offering and capability building helpers mixed into Provider.
+        module OfferingBuilder
+          private
+
           def offering_from_model(model, health: {})
             policy = Legion::Extensions::Llm::CapabilityPolicy.resolve(
               real: real_capabilities_from(model),
@@ -350,54 +281,39 @@ module Legion
             methods = Array(meta[:supported_generation_methods] || meta['supported_generation_methods'])
             {
               streaming: methods.include?('streamGenerateContent'),
-              embeddings: methods.include?('embedContent'),
-              vision: Capabilities.vision?(meta.merge('name' => "models/#{model.id}"))
+              embedding: methods.include?('embedContent'),
+              vision: Legion::Extensions::Llm::Gemini::Provider::Capabilities.vision?(
+                meta.merge('name' => "models/#{model.id}")
+              )
             }.compact
           end
 
           def provider_capability_config
-            return {} unless defined?(Legion::Extensions::Llm::CredentialSources)
-
             conf = Legion::Extensions::Llm::CredentialSources.setting(:extensions, :llm, :gemini)
             conf.is_a?(Hash) ? conf.to_h.except(:instances, 'instances') : {}
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'gemini.provider_capability_config')
+            handle_exception(e, level: :warn, handled: true, operation: 'gemini.provider_capability_config')
             {}
           end
 
           def instance_capability_config
-            cfg = config
-            result = {}
-            %i[capabilities enable_streaming enable_tools enable_thinking enable_vision enable_embeddings
-               thinking_flag tools_flag streaming_flag vision_flag embedding_flag embeddings_flag
-               tool_flag images_flag image_flag].each do |key|
-              next unless cfg.respond_to?(key)
-
-              val = cfg.send(key)
-              result[key] = val unless val.nil?
-            rescue StandardError
-              next
-            end
-            result
+            config.to_h.slice(*Legion::Extensions::Llm::Provider::CAPABILITY_CONFIG_KEYS)
           end
 
           def model_capability_config(model_id)
-            models_conf = resolve_models_config
-            return {} unless models_conf.respond_to?(:to_h)
+            hash = resolve_models_config
+            return {} unless hash.is_a?(Hash)
 
-            hash = models_conf.to_h
             hash[model_id.to_s] || hash[model_id.to_sym] || {}
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'gemini.model_capability_config')
+            handle_exception(e, level: :warn, handled: true, operation: 'gemini.model_capability_config')
             {}
           end
 
           def resolve_models_config
-            return config.models if config.respond_to?(:models)
-            return config[:models] if config.respond_to?(:[])
-
-            nil
-          rescue StandardError
+            config.to_h[:models]
+          rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'gemini.resolve_models_config')
             nil
           end
 
@@ -406,21 +322,105 @@ module Legion
 
             [%w[text image audio video], %w[text]]
           end
+        end
 
-          def render_embedding_payload(text, model:, dimensions:)
-            {
-              model: model_path(model),
-              content: { parts: [{ text: text.to_s }] },
-              outputDimensionality: dimensions
-            }.compact
+        # Gemini provider implementation for the Legion::Extensions::Llm base provider contract.
+        class Provider < Legion::Extensions::Llm::Provider
+          include Legion::Logging::Helper
+          include MessageFormatter
+          include ResponseParser
+          include OfferingBuilder
+
+          class << self
+            def slug = 'gemini'
+            def configuration_options = %i[gemini_api_key gemini_api_base]
+            def configuration_requirements = %i[gemini_api_key]
+            def capabilities = Capabilities
           end
 
-          def parse_embedding_response(response, model:, **)
-            Legion::Extensions::Llm::Embedding.new(
-              vectors: response.body.dig('embedding', 'values'),
-              model: model,
-              input_tokens: response.body.dig('usageMetadata', 'promptTokenCount').to_i
-            )
+          # Capability predicates for Gemini API models.
+          module Capabilities
+            module_function
+
+            def chat?(model) = supported?(model, 'generateContent')
+            def streaming?(model) = supported?(model, 'streamGenerateContent')
+            def embeddings?(model) = supported?(model, 'embedContent')
+            def vision?(model) = chat?(model) && model_id(model).match?(/gemini|flash|pro/)
+            def functions?(model) = chat?(model)
+
+            def critical_capabilities_for(model)
+              [
+                ('streaming' if streaming?(model)),
+                ('embedding' if embeddings?(model)),
+                ('tools' if functions?(model)),
+                ('vision' if vision?(model))
+              ].compact
+            end
+
+            # When generation methods are absent, treat all capabilities as unknown
+            # (unknown = unsupported for selection). Only fall back to name heuristic
+            # for embedContent to preserve legacy embedding detection.
+            def supported?(model, action)
+              methods = generation_methods(model)
+              return model_id(model).include?('embedding') if methods.empty?
+
+              methods.include?(action)
+            end
+
+            def generation_methods(model)
+              metadata = metadata_for(model)
+              Array(metadata[:supported_generation_methods] || metadata['supported_generation_methods'] ||
+                    metadata['supportedGenerationMethods'])
+            end
+
+            def model_id(model)
+              return model.fetch('name', '').delete_prefix('models/') if model.is_a?(Hash)
+
+              model.respond_to?(:id) ? model.id.to_s : model.to_s
+            end
+
+            def metadata_for(model)
+              return model if model.is_a?(Hash)
+              return model.metadata if model.respond_to?(:metadata)
+
+              {}
+            end
+          end
+
+          def settings
+            Gemini.default_settings
+          end
+
+          def api_base
+            config.gemini_api_base || settings[:instances][:default][:endpoint]
+          end
+
+          def headers
+            identity_headers.merge('x-goog-api-key' => config.gemini_api_key)
+          end
+
+          def completion_url = generate_content_url(model: @model)
+          def stream_url = stream_generate_content_url(model: @model)
+          def models_url = 'models'
+          def embedding_url(model:) = embed_content_url(model:)
+
+          def generate_content_url(model:)
+            "#{model_path(model)}:generateContent"
+          end
+
+          def stream_generate_content_url(model:)
+            "#{model_path(model)}:streamGenerateContent?alt=sse"
+          end
+
+          def embed_content_url(model:)
+            "#{model_path(model)}:embedContent"
+          end
+
+          def list_models(**)
+            log.info { 'listing available Gemini models' }
+            super.tap do |models|
+              log.info { "discovered #{models.size} Gemini model(s)" }
+            end
           end
         end
       end

data/lib/legion/extensions/llm/gemini/runners/fleet_worker.rb

@@ -9,17 +9,23 @@ module Legion
       module Gemini
         module Runners
           # Runner entrypoint for Gemini fleet request execution.
+          #
+          # The Subscription dispatch path invokes this as
+          # runner_class.send(fn, **message) where message is the fleet
+          # request envelope merged with transport metadata (routing_key,
+          # message_id, headers, ...). The responder parses the envelope out
+          # of that hash; unknown keys are inert.
           module FleetWorker
             module_function
 
-            def handle_fleet_request(payload, delivery: nil, properties: nil)
+            def handle_fleet_request(**opts)
               Legion::Extensions::Llm::Fleet::ProviderResponder.call(
-                payload: payload,
+                payload: opts,
                 provider_family: Gemini::PROVIDER_FAMILY,
                 provider_class: Gemini::Provider,
                 provider_instances: -> { Gemini.discover_instances },
-                delivery: delivery,
-                properties: properties
+                delivery: opts[:delivery],
+                properties: opts[:properties]
               )
             end
           end

data/lib/legion/extensions/llm/gemini/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Gemini
-        VERSION = '0.3.13'
+        VERSION = '0.4.4'
       end
     end
   end

data/lib/legion/extensions/llm/gemini.rb

@@ -3,7 +3,7 @@
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/gemini/provider'
 require 'legion/extensions/llm/gemini/version'
-require_relative 'gemini/actors/discovery_refresh'
+require 'legion/extensions/llm/gemini/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -11,7 +11,6 @@ module Legion
     module Llm
       # Gemini provider extension namespace.
       module Gemini
-        extend ::Legion::Extensions::Core if ::Legion::Extensions.const_defined?(:Core, false)
         extend Legion::Logging::Helper
         extend Legion::Extensions::Llm::AutoRegistration
 
@@ -22,7 +21,7 @@ module Legion
             family: PROVIDER_FAMILY,
             instance: {
               endpoint: 'https://generativelanguage.googleapis.com/v1beta',
-              default_model: 'gemini-2.0-flash',
+              discovery_interval: 3600,
               tier: :frontier,
               transport: :http,
               credentials: { api_key: 'env://GEMINI_API_KEY' },
@@ -69,7 +68,7 @@ module Legion
 
           candidates[:settings] = normalize_instance_config(cfg).merge(api_key: api_key,
                                                                        gemini_api_key: api_key,
-                                                                       tier: :cloud)
+                                                                       tier: cfg[:tier] || cfg['tier'] || :cloud)
         end
 
         def self.add_settings_instances(candidates, cfg)
@@ -83,17 +82,30 @@ module Legion
             next unless normalized[:gemini_api_key]
 
             normalized[:api_key] = normalized[:gemini_api_key]
-            candidates[name.to_sym] = normalized.merge(tier: :cloud)
+            normalized[:tier] ||= :cloud
+            candidates[name.to_sym] = normalized
           end
         end
 
-        def self.normalize_instance_config(config) # rubocop:disable Metrics/AbcSize
-          normalized = config.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+        def self.normalize_instance_config(config)
+          normalized = symbolize_config_keys(config)
+          promote_api_key(normalized)
+          promote_api_base(normalized)
+          normalized.compact.except(:instances)
+        end
+
+        def self.symbolize_config_keys(config)
+          config.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+        end
+
+        def self.promote_api_key(normalized)
           normalized[:gemini_api_key] ||= normalized.delete(:api_key)
+        end
+
+        def self.promote_api_base(normalized)
           normalized[:gemini_api_base] ||= normalized.delete(:base_url)
           normalized[:gemini_api_base] ||= normalized.delete(:api_base)
           normalized[:gemini_api_base] ||= normalized.delete(:endpoint)
-          normalized.compact.except(:instances)
         end
 
         def self.sanitize_instance_config(config)
@@ -102,6 +114,7 @@ module Legion
 
         private_class_method :discover_from_env, :discover_from_settings,
                              :add_settings_api_key, :add_settings_instances, :normalize_instance_config,
+                             :symbolize_config_keys, :promote_api_key, :promote_api_base,
                              :sanitize_instance_config
 
         Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-gemini
 version: !ruby/object:Gem::Version
-  version: 0.3.13
+  version: 0.4.4
 platform: ruby
 authors:
 - LegionIO
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.14
+        version: 1.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.14
+        version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: legion-transport
   requirement: !ruby/object:Gem::Requirement
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.7.1
 description: Gemini provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com