lex-llm-gemini 0.3.10 → 0.3.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 101069a5f61b6c4a90fe236e40c54ef3af55bdd00d7b6816495eb255aa61cad4
-  data.tar.gz: adf84ed406fb7419fab87b7a0fc42b123abda739b20889dec8aead89c3adffef
+  metadata.gz: 564af323ba9c521e6404595eb47f3c1470da8459aec2790c42f51d004e3c2394
+  data.tar.gz: 4a7bce02b3c4399425ed0749ca5fb580e67d445af04c85480c7b1c0d33a01782
 SHA512:
-  metadata.gz: 4b9d7c32d2953485fcd5000b7139012eb1d69470936d8e7a0eadf56b030bbf1b412754f392248c58ff028d17d2e037464384442674a7d5e46699b8844c25202a
-  data.tar.gz: 941d8fa9761befe73c8324db0452807f073c644f958a0d174dd68fd27be9448172653110dc6cb4e6cd739ea88419c1e0a4f8c5ce614939590171fb36db8f6233
+  metadata.gz: 62157a365a6a265791ae7ec076332976241b3137076e5b8fa5f389625b035679ac38afa9ff16324b578f1ab2d9cd35e33b30564eb37a7870eda05dee66ae40cf
+  data.tar.gz: 98c631924f43613cf28f034a972ef8b2326d88286364768094640080a68e5daf73bdd945ce60867cce6f58f75d6640fc65c0235738c3e7a3d7dd374602f0069f

data/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## [0.3.18] - 2026-08-04
+
+### Changed
+- Prepare the Gemini provider standardization baseline for a patch release.
+
+## [0.3.17] - 2026-07-02
+
+### Fixed
+- Emit canonical capability vocabulary (`:embedding`, `:tools`) from `Capabilities.critical_capabilities_for`. `lex-llm` 0.6.1+ retains both the raw and canonical forms on `Model::Info`, so the pre-canonical aliases (`embeddings`, `function_calling`) leaked duplicate tokens (e.g. `[:embeddings, :embedding]`) into discovered model capabilities.
+
+## [0.3.16] - 2026-06-20
+
+### Fixed
+- Stub shared registry publishing through `RegistryPublisher#schedule` in specs so async availability-event coverage stays stable after the shared publisher moved off raw `Thread.new`.
+
+## [0.3.15] - 2026-06-20
+
+### Changed
+- Align Gemini instance discovery with the shared `lex-llm` contract by preserving explicit tier overrides while defaulting unconfigured instances to `:cloud`.
+- Expand instance-level capability override passthrough to the shared `enable_*` vocabulary, including `structured_output`.
+- Normalize Gemini contract coverage around canonical `:tools` and `:embedding` capabilities.
+
+## [0.3.14] - 2026-06-19
+
+### Changed
+- Adopt `Legion::Extensions::Llm::Inventory::ScopedRefresher` mixin (lex-llm 0.6.0). Discovery
+  refresh actors now write directly to the live `Inventory` catalog via `Inventory.write_lane`.
+- Pin `lex-llm >= 0.6.0` and `legion-llm >= 0.14.0` in gemspec.
+- Standard `weight: 100` default added to provider instance settings schema.
+
+## 0.3.13 - 2026-06-16
+
+- Dependency updates, code quality improvements.
+
+## 0.3.12 - 2026-06-15
+
+- **CapabilityPolicy integration** — `supportedGenerationMethods` mapped to `:model_metadata`. Settings overrides at provider/instance/model level supported.
+
+## 0.3.11 - 2026-06-13
+
+- **Gemfile cleanup** — Remove local path overrides; dependencies resolve from gemspec via rubygems.
+- **Dependency bump** — Require `lex-llm >= 0.5.0` for canonical types support.
+- **Canonical tool support** — Use `ToolSchema.extract` and add `:tools` capability.
+- **Bug fix** — Handle Array tool_calls in `tool_call_parts`.
+- 22 examples, 0 failures; 13 files, 0 rubocop offenses.
+
 ## 0.3.10 - 2026-06-02
 
 - Add per-provider scoped discovery refresh actor

data/Gemfile

@@ -2,13 +2,6 @@
 
 source 'https://rubygems.org'
 
-group :test do
-  llm_base_path = ENV.fetch('LEX_LLM_PATH', File.expand_path('../lex-llm', __dir__))
-  transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
-  gem 'legion-transport', path: transport_path if File.directory?(transport_path)
-  gem 'lex-llm', path: llm_base_path if File.directory?(llm_base_path)
-end
-
 gemspec
 
 group :development do

data/lex-llm-gemini.gemspec

@@ -27,5 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.14'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  spec.add_dependency 'lex-llm', '>= 0.4.3'
+  spec.add_dependency 'lex-llm', '>= 0.6.0'
 end

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

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 begin
   require 'legion/extensions/actors/every'
 rescue LoadError => e
   warn(e.message) if $VERBOSE
 end
 
+begin
+  require 'legion/extensions/llm/inventory/scoped_refresher'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
 return unless defined?(Legion::Extensions::Actors::Every)
 
 module Legion
@@ -13,10 +21,14 @@ module Legion
     module Llm
       module Gemini
         module Actor
-          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation
+          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation,Metrics/ClassLength
             include Legion::Logging::Helper
 
-            REFRESH_INTERVAL = 1800
+            if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+              include Legion::Extensions::Llm::Inventory::ScopedRefresher
+            end
+
+            def self.every_seconds = 3600
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -26,19 +38,137 @@ module Legion
             def generate_task?  = false
 
             def time
-              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+              return self.class.every_seconds unless defined?(Legion::Settings)
 
-              Legion::Settings.dig(:extensions, :llm, :gemini, :discovery_interval) || REFRESH_INTERVAL
+              Legion::Settings.dig(:extensions, :llm, :gemini, :discovery_interval) || self.class.every_seconds
             end
 
-            def manual
-              log.debug('[gemini][discovery_refresh] refreshing model list')
-              return unless defined?(Legion::LLM::Discovery)
+            def scope_key(**)
+              { provider: :gemini }
+            end
 
-              Legion::LLM::Discovery.refresh_discovered_models!(provider: :gemini)
+            def compute_lanes_for_scope(**)
+              return [] unless defined?(Legion::LLM::Call::Registry)
+
+              lanes = []
+              gemini_instances.each do |instance|
+                collect_lanes_for_instance(instance, lanes)
+              rescue StandardError => e
+                handle_exception(e, level: :warn, handled: true,
+                                    operation: 'gemini.discovery_refresh.compute_lanes',
+                                    instance: instance[:id])
+              end
+              lanes
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true,
+                                  operation: 'gemini.discovery_refresh.compute_lanes_for_scope')
+              []
+            end
+
+            def credential_hash(**)
+              settings = gemini_settings
+              Digest::SHA256.hexdigest(settings[:api_key].to_s + settings[:instances].to_s)[0, 16]
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'gemini.discovery_refresh.credential_hash')
+              'unknown'
+            end
+
+            def manual(**)
+              tick if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher) &&
+                      respond_to?(:tick, true)
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'gemini.actor.discovery_refresh')
             end
+
+            private
+
+            def gemini_instances
+              Legion::LLM::Call::Registry.all_instances.select do |e|
+                (e[:provider] || '').to_sym == :gemini
+              end
+            end
+
+            def collect_lanes_for_instance(instance, lanes)
+              adapter = instance[:adapter]
+              return unless adapter.respond_to?(:discover_offerings)
+
+              Array(adapter.discover_offerings(live: false)).each do |raw_offering|
+                offering = offering_to_hash(raw_offering)
+                next unless offering
+
+                model = offering[:model] || offering['model']
+                next unless model
+
+                lane = build_lane(offering, instance)
+                lanes << lane
+                lanes << fleet_lane(lane, instance) if emit_fleet_lane?(lane)
+              end
+            end
+
+            def offering_to_hash(offering)
+              return nil if offering.nil?
+              return offering if offering.is_a?(Hash)
+
+              hash = offering.to_h
+              hash[:type] ||= hash[:usage_type]
+              hash[:enabled] = offering.respond_to?(:enabled?) ? offering.enabled? : true
+              hash
+            end
+
+            def build_lane(offering, instance) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+              instance_id  = instance[:instance] || instance[:instance_id] || instance[:id]
+              raw_tier     = offering[:tier] || :frontier
+              offer_type   = offering[:type]
+              type         = %i[embed embedding].include?(offer_type) ? :embedding : :inference
+              capabilities = normalize_capabilities(offering[:capabilities] || [])
+              model        = offering[:model] || offering['model']
+
+              lane_id = Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(
+                tier: raw_tier, provider_family: :gemini,
+                instance_id: instance_id, type: type, model: model
+              )
+
+              {
+                id: lane_id,
+                tier: raw_tier,
+                provider_family: :gemini,
+                instance_id: instance_id,
+                model: model,
+                canonical_model_alias: offering[:canonical_model_alias] || offering[:name],
+                type: type,
+                capabilities: capabilities,
+                limits: offering[:limits] || {},
+                enabled: offering.fetch(:enabled, true),
+                cost: offering[:cost] || {}
+              }
+            end
+
+            def emit_fleet_lane?(lane)
+              return false unless lane[:type] == :inference
+
+              gemini_settings&.dig(:fleet, :dispatch, :enabled)
+            end
+
+            def fleet_lane(lane, instance)
+              fleet_id = Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(
+                tier: :fleet, provider_family: :gemini,
+                instance_id: instance[:instance] || instance[:instance_id] || instance[:id],
+                type: lane[:type], model: lane[:model]
+              )
+              lane.merge(id: fleet_id, tier: :fleet)
+            end
+
+            def normalize_capabilities(caps)
+              return [] unless defined?(Legion::Extensions::Llm::Inventory::Capabilities)
+
+              Legion::Extensions::Llm::Inventory::Capabilities.normalize(caps)
+            end
+
+            def gemini_settings
+              Legion::Settings.dig(:extensions, :llm, :gemini)
+            rescue StandardError
+              {}
+            end
           end
         end
       end

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

@@ -33,11 +33,14 @@ module Legion
             def vision?(model) = chat?(model) && model_id(model).match?(/gemini|flash|pro/)
             def functions?(model) = chat?(model)
 
+            # Emit canonical capability vocabulary (see Legion::Extensions::Llm::Capabilities::CANONICAL).
+            # Model::Info retains both raw and canonical forms, so aliases like :embeddings/:function_calling
+            # would otherwise leak duplicate tokens into the capability list.
             def critical_capabilities_for(model)
               [
                 ('streaming' if streaming?(model)),
-                ('embeddings' if embeddings?(model)),
-                ('function_calling' if functions?(model)),
+                ('embedding' if embeddings?(model)),
+                ('tools' if functions?(model)),
                 ('vision' if vision?(model))
               ].compact
             end
@@ -187,7 +190,9 @@ module Legion
           end
 
           def tool_call_parts(message)
-            message.tool_calls.values.map do |tool_call|
+            # 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 } }
             end
           end
@@ -204,9 +209,12 @@ module Legion
           def format_tools(tools)
             [{
               functionDeclarations: tools.values.map do |tool|
-                declaration = { name: tool.name, description: tool.description }
-                declaration[:parameters] = tool.params_schema if tool.params_schema
-                declaration
+                schema = Legion::Extensions::Llm::Canonical::ToolSchema.extract(tool)
+                {
+                  name: Legion::Extensions::Llm::Canonical::ToolSchema.tool_name(tool),
+                  description: Legion::Extensions::Llm::Canonical::ToolSchema.tool_description(tool),
+                  parameters: schema
+                }
               end
             }]
           end
@@ -307,6 +315,85 @@ module Legion
             end
           end
 
+          # -- policy resolution requires many sources
+          def offering_from_model(model, health: {})
+            policy = Legion::Extensions::Llm::CapabilityPolicy.resolve(
+              real: real_capabilities_from(model),
+              provider_catalog: {},
+              probe: {},
+              provider_envelope: {},
+              provider_config: provider_capability_config,
+              instance_config: instance_capability_config,
+              model_config: model_capability_config(model.id)
+            )
+
+            build_model_offering(model, policy, health)
+          end
+
+          def build_model_offering(model, policy, health)
+            Routing::ModelOffering.new(
+              provider_family: slug.to_sym,
+              provider_instance: model.instance || provider_instance_id,
+              transport: offering_transport,
+              tier: offering_tier,
+              model: model.id,
+              canonical_model_alias: model.name,
+              model_family: model.family,
+              usage_type: offering_usage_type(model),
+              capabilities: policy[:capabilities],
+              capability_sources: policy[:sources],
+              limits: offering_limits(model),
+              health:,
+              metadata: offering_metadata(model)
+            )
+          end
+
+          def real_capabilities_from(model)
+            meta = model.respond_to?(:metadata) ? (model.metadata || {}) : {}
+            methods = Array(meta[:supported_generation_methods] || meta['supported_generation_methods'])
+            {
+              streaming: methods.include?('streamGenerateContent'),
+              embedding: methods.include?('embedContent'),
+              vision: 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: :warn, handled: true, operation: 'gemini.provider_capability_config')
+            {}
+          end
+
+          def instance_capability_config
+            return {} unless config.respond_to?(:to_h)
+
+            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 = models_conf.to_h
+            hash[model_id.to_s] || hash[model_id.to_sym] || {}
+          rescue StandardError => e
+            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
+            nil
+          end
+
           def modalities_for(methods)
             return [%w[text], %w[embeddings]] if methods.include?('embedContent')
 

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Gemini
-        VERSION = '0.3.10'
+        VERSION = '0.3.18'
       end
     end
   end

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

@@ -3,6 +3,7 @@
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/gemini/provider'
 require 'legion/extensions/llm/gemini/version'
+require_relative 'gemini/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -30,10 +31,7 @@ module Legion
               fleet: {
                 enabled: false,
                 respond_to_requests: false,
-                capabilities: %i[chat stream_chat embed],
-                lanes: [],
-                concurrency: 4,
-                queue_suffix: nil
+                capabilities: %i[chat stream_chat embed tools]
               }
             }
           )
@@ -71,7 +69,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)
@@ -85,7 +83,8 @@ 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
 
@@ -106,8 +105,7 @@ module Legion
                              :add_settings_api_key, :add_settings_instances, :normalize_instance_config,
                              :sanitize_instance_config
 
-        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options) if
-          Legion::Extensions::Llm::Configuration.respond_to?(:register_provider_options)
+        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-gemini
 version: !ruby/object:Gem::Version
-  version: 0.3.10
+  version: 0.3.18
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.6.0
 description: Gemini provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com