lex-llm-ollama 0.2.17 → 0.2.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7850eb1a4f0fcf50d9d0a86de7b9c2e60fa47154e1c6b330a492abeb00c25803
-  data.tar.gz: 24e040db015065dd7e508a995aa0f2b072910da41552029a1ff561993961331a
+  metadata.gz: fe9668a684e60453a26c187e8e5dddfa15835ce18b4b6d627cb32bd17be1fef8
+  data.tar.gz: a858a4b969945856c39ba64397067ef1f7c8c776de47b669a1e7b7c8a6704abf
 SHA512:
-  metadata.gz: 762912cf8067d8b1c9019ea2d1d10261e234abac127ad1eeeecb5d2b7e41219c09f6294f68f022f0ad33b1f2eb95332db8b1ed3521eeef84aecfbeb11c3f186e
-  data.tar.gz: 9f99c4bc9f342d1061077d9dd8f663b35a0a9c962515cddbcf76d19a55fa734040ab8f4b7f7fd6767395d3dd9582913c6b2dbd3ac3010d10c787e932f218fd6a
+  metadata.gz: 52b01a8dfa63402561d7e5e9b09ed09d92ac7d01ef9dfa0fa04e15463399da4168f6948f0f23e5d1807d6b2f09f04d103079ff35959077d717bbb2f2889fa7aa
+  data.tar.gz: 3fccbb4c70de27e38f87d4809f628819f33ff9ce4a3640b7cf29c67deda5b01ed394797b7c1ddb438f980d680d2bd0c8768b4388a2e57ff8e1d62f1cc4ccc5b5

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## [0.2.24] - 2026-07-24
+
+### Fixed
+- **Translator propagates `done_reason` and usage through content chunks.** When ollama sends `done: true` on a chunk that also has content, the stop_reason and usage were previously lost. Now extracts them before branching and passes through to whatever chunk type is emitted.
+
+## [0.2.23] - 2026-07-05
+
+### Changed
+- Stop_reason mapping now uses the shared `Legion::Extensions::Llm::StopReasonMapping` mixin from lex-llm (>= 0.6.9) instead of a local `OLLAMA_STOP_REASON_MAP` (a copy of the same drifting 3-entry map vLLM carried). The shared vocabulary maps `tool_calls`/`tool_use`/`function_call` to `:tool_use` (plus `stop`/`end_turn`/`eos`, `length`/`max_tokens`, `stop_sequence`, `content_filter`) and is inherited by every provider so it no longer drifts per gem. Ollama's `done_reason`-to-stop_reason resolution is unchanged in behavior.
+
+## [0.2.22] - 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.2.21] - 2026-06-20
+
+### Fixed
+- Stop bulk-publishing Ollama model availability from `list_models`; discovery now emits one registry event per seen model from the shared `lex-llm` policy-filter path so blocked models stay observable without duplicate publishes.
+
+## [0.2.20] - 2026-06-20
+
+### Changed
+- Slow the live discovery refresh cadence from 60 seconds to 300 seconds for Ollama instances; `extensions.llm.ollama.discovery_interval` still overrides the default.
+
+## [0.2.19] - 2026-06-20
+
+### Fixed
+- Route Ollama capability overrides through the shared `lex-llm` provider contract and preserve the canonical singular `:embedding` capability on embedding offerings.
+
+## [0.2.18] - 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.2.17 - 2026-06-16
 
 - dependency updates, code quality improvements

data/lex-llm-ollama.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.5.0'
+  spec.add_dependency 'lex-llm', '>= 0.6.9'
 end

data/lib/legion/extensions/llm/ollama/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
@@ -16,7 +24,11 @@ module Legion
           class DiscoveryRefresh < Legion::Extensions::Actors::Every
             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 = 300
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -26,25 +38,143 @@ 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, :ollama, :discovery_interval) || REFRESH_INTERVAL
+              Legion::Settings.dig(:extensions, :llm, :ollama, :discovery_interval) || self.class.every_seconds
             end
 
-            def manual
-              log.debug('[ollama][discovery_refresh] refreshing model list')
-              return unless defined?(Legion::LLM::Discovery)
+            def scope_key(**)
+              { provider: :ollama }
+            end
 
-              Legion::LLM::Discovery.refresh_discovered_models!(provider: :ollama)
-              if defined?(Legion::LLM::Router) && Legion::LLM::Router.respond_to?(:populate_auto_rules)
-                Legion::LLM::Router.populate_auto_rules(Legion::LLM::Discovery.discovered_instances)
-              end
-              if defined?(Legion::LLM::Inventory) && Legion::LLM::Inventory.respond_to?(:invalidate_offerings_cache!)
-                Legion::LLM::Inventory.invalidate_offerings_cache!
+            def compute_lanes_for_scope(**)
+              return [] unless defined?(Legion::LLM::Call::Registry)
+
+              lanes = []
+              ollama_instances.each do |instance|
+                collect_lanes_for_instance(instance, lanes)
+              rescue StandardError => e
+                handle_exception(e, level: :warn, handled: true,
+                                    operation: 'ollama.discovery_refresh.compute_lanes',
+                                    instance: instance[:instance])
               end
+              lanes
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true,
+                                  operation: 'ollama.discovery_refresh.compute_lanes_for_scope')
+              []
+            end
+
+            def credential_hash(**)
+              settings = ollama_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: 'ollama.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: 'ollama.actor.discovery_refresh')
             end
+
+            private
+
+            def ollama_instances
+              Legion::LLM::Call::Registry.all_instances.select do |e|
+                (e[:provider] || '').to_sym == :ollama
+              end
+            end
+
+            def collect_lanes_for_instance(instance, lanes)
+              adapter = instance[:adapter]
+              return unless adapter.respond_to?(:discover_offerings)
+
+              Array(adapter.discover_offerings(live: true)).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)
+              instance_id  = instance[:instance] || instance[:instance_id] || instance[:id]
+              raw_tier     = offering[:tier] || :local
+              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: :ollama,
+                instance_id: instance_id, type: type, model: model
+              )
+
+              {
+                id: lane_id,
+                tier: raw_tier,
+                provider_family: :ollama,
+                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
+
+              ollama_settings&.dig(:fleet, :dispatch, :enabled)
+            end
+
+            def fleet_lane(lane, instance)
+              fleet_id = Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(
+                tier: :fleet, provider_family: :ollama,
+                instance_id: instance[:instance] || instance[:instance_id],
+                type: lane[:type], model: lane[:model]
+              )
+              lane.merge(id: fleet_id, tier: :fleet)
+            end
+
+            def normalize_capabilities(caps)
+              # Inventory::Capabilities lives in lex-llm; the previous fallback (`return []
+              # unless defined?(...)`) silently swallowed every capability the operator
+              # declared via enable_thinking/enable_tools when the constant wasn't loaded.
+              # Always normalize through the shared vocabulary so aliases collapse.
+              if defined?(Legion::Extensions::Llm::Inventory::Capabilities)
+                Legion::Extensions::Llm::Inventory::Capabilities.normalize(caps)
+              else
+                Array(caps).compact.map(&:to_sym).uniq
+              end
+            end
+
+            def ollama_settings
+              Legion::Settings.dig(:extensions, :llm, :ollama)
+            rescue StandardError
+              {}
+            end
           end
         end
       end

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

@@ -77,14 +77,27 @@ module Legion
             end
           end
 
-          def list_models
+          def list_models(live: false, **filters)
             log.debug { "ollama provider discovering models endpoint=#{api_base}#{models_url}" }
             super.tap do |models|
               log.debug { "ollama provider discovered model_count=#{models.size}" }
-              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
             end
           end
 
+          def discover_offerings(live: false, raise_on_unreachable: false, **filters)
+            return filter_cached_offerings(Array(@cached_offerings), filters) unless live
+
+            provider_health = health(live:)
+            @cached_offerings = discover_live_offerings(filters, provider_health, live:)
+            log_discover_complete(@cached_offerings)
+            @cached_offerings
+          rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+            log.warn("[#{slug}] instance=#{provider_instance_id} unreachable: #{e.message}")
+            raise if raise_on_unreachable
+
+            []
+          end
+
           def show_model(model)
             log.debug { "ollama provider fetching model details model=#{model}" }
             connection.post(show_model_url, { model: model }).body
@@ -112,25 +125,42 @@ module Legion
             raise
           end
 
-          def discover_offerings(live: false, **)
-            log.debug do
-              "ollama provider discovering offerings live=#{live} cached_model_count=#{Array(@cached_models).size}"
-            end
-            running_ids = live ? running_model_ids : []
-            offerings = resolve_models(live).filter_map do |model_info|
-              next unless model_allowed?(model_info.id)
+          private
 
-              offering_from_model(model_info, loaded: running_ids.include?(model_info.id.to_s))
+          def discovery_registry_readiness(provider_health, live:)
+            {
+              provider: slug.to_sym,
+              configured: configured?,
+              ready: provider_health[:ready] == true,
+              live: live,
+              health: provider_health
+            }
+          end
+
+          def discover_live_offerings(filters, provider_health, live:)
+            readiness = discovery_registry_readiness(provider_health, live:)
+            Array(list_models(live:, **filters)).filter_map do |model|
+              self.class.registry_publisher.publish_models_async([model], readiness:)
+              next unless model_matches_filters?(model, filters)
+              next unless model_allowed?(model.id)
+
+              log_model_discovered(model)
+              offering_from_model(model, health: provider_health)
             end
-            log.debug { "ollama provider built offering_count=#{offerings.size} live=#{live}" }
-            offerings
-          rescue Faraday::ConnectionFailed => e
-            log.warn("[ollama] instance=#{provider_instance_id} unreachable: #{e.message}")
-            []
-          rescue StandardError => e
-            handle_exception(e, level: :warn, handled: true, operation: 'ollama.discover_offerings',
-                                backtrace_limit: 3)
-            []
+          end
+
+          def log_model_discovered(model)
+            log.debug(
+              "[#{slug}] instance=#{provider_instance_id} action=model_discovered " \
+              "model=#{model.id} family=#{model.family}"
+            )
+          end
+
+          def log_discover_complete(offerings)
+            log.info(
+              "[#{slug}] instance=#{provider_instance_id} action=discover_complete " \
+              "model_count=#{Array(offerings).size}"
+            )
           end
 
           CONTEXT_WINDOWS = {
@@ -154,8 +184,6 @@ module Legion
             'bge' => 512
           }.freeze
 
-          private
-
           def resolve_models(live)
             if live
               @cached_models = list_models
@@ -170,8 +198,20 @@ module Legion
             end.map(&:to_s)
           end
 
-          def offering_from_model(model_info, loaded: false)
+          def offering_from_model(model_info, health: {})
+            loaded = begin
+              running_model_ids.include?(model_info.id.to_s)
+            rescue StandardError
+              health.is_a?(Hash) ? health.fetch(:loaded, false) : false
+            end
             policy = resolve_capability_policy(model_info)
+            embedding_model = model_info.embedding?
+            capabilities = embedding_model ? [:embedding] : policy[:capabilities]
+            capability_sources = if embedding_model
+                                   policy[:sources].merge(embedding: { value: true, source: :model_metadata })
+                                 else
+                                   policy[:sources]
+                                 end
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :ollama,
               instance_id: config.respond_to?(:instance_id) ? config.instance_id : :default,
@@ -179,8 +219,8 @@ module Legion
               tier: offering_tier,
               model: model_info.id,
               usage_type: offering_usage_type(model_info),
-              capabilities: policy[:capabilities],
-              capability_sources: policy[:sources],
+              capabilities: capabilities,
+              capability_sources: capability_sources,
               limits: offering_limits(model_info),
               metadata: offering_metadata(model_info).merge(loaded: loaded)
             )
@@ -193,9 +233,9 @@ module Legion
               provider_catalog: {},
               probe: {},
               provider_envelope: { streaming: true },
-              provider_config: provider_level_config,
-              instance_config: instance_level_config,
-              model_config: model_level_config(model_id)
+              provider_config: provider_capability_config,
+              instance_config: instance_capability_config,
+              model_config: model_capability_config(model_id)
             )
           end
 
@@ -206,35 +246,6 @@ module Legion
             end
           end
 
-          def provider_level_config
-            raw = CredentialSources.setting(:extensions, :llm, :ollama)
-            return {} unless raw.is_a?(Hash)
-
-            raw.reject { |k, _| k.to_sym == :instances }
-          end
-
-          def instance_level_config
-            extract_config_hash
-          end
-
-          def model_level_config(model_id)
-            data = extract_config_hash
-            models = data[:models]
-            return {} unless models.is_a?(Hash)
-
-            models[model_id.to_sym] || models[model_id.to_s] || models[model_id] || {}
-          end
-
-          def extract_config_hash
-            return config.to_h if config.respond_to?(:to_h) && !config.is_a?(Legion::Extensions::Llm::HashConfig)
-
-            if config.is_a?(Legion::Extensions::Llm::HashConfig)
-              config.instance_variable_get(:@data) || {}
-            else
-              {}
-            end
-          end
-
           def offering_usage_type(model_info)
             model_info.embedding? ? :embedding : :inference
           end
@@ -352,7 +363,7 @@ module Legion
             chunks << built
             block&.call(built)
           rescue Legion::JSON::ParseError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'ollama.stream_parse')
+            handle_exception(e, level: :warn, handled: true, operation: 'ollama.stream_parse')
           end
 
           def finalize_stream(chunks)

data/lib/legion/extensions/llm/ollama/translator.rb

@@ -21,13 +21,10 @@ module Legion
         # - assistant_prefill: false — Ollama does not support assistant prefill.
         class Translator
           include Legion::Logging::Helper
+          # Shared stop_reason vocabulary. Ollama returns structured tool_calls and
+          # OpenAI-style done_reason strings; inherits the common map.
+          include Legion::Extensions::Llm::StopReasonMapping
 
-          # Ollama-specific stop_reason mapping (done_reason field).
-          OLLAMA_STOP_REASON_MAP = {
-            'stop' => :end_turn,
-            'tool_use' => :tool_use,
-            'length' => :max_tokens
-          }.freeze
           FALLBACK_STOP_REASON = :end_turn
 
           # G18 parameter mapping: canonical params -> Ollama options keys.
@@ -392,7 +389,7 @@ module Legion
 
           def map_stop_reason(done_reason, done = nil)
             if done_reason
-              OLLAMA_STOP_REASON_MAP.fetch(done_reason.to_s, FALLBACK_STOP_REASON)
+              stop_reason_lookup(done_reason) || FALLBACK_STOP_REASON
             elsif done
               FALLBACK_STOP_REASON
             end
@@ -420,16 +417,24 @@ module Legion
             done_reason = data[:done_reason] || data['done_reason']
             request_id = data[:request_id] || data['request_id'] || data[:id] || data['id']
 
+            chunk_stop_reason = done_reason ? map_stop_reason(done_reason, done) : nil
+            chunk_usage = done ? build_chunk_usage(data) : nil
+
             # Tool call delta
             tool_calls = message[:tool_calls] || message['tool_calls']
-            return build_tool_call_chunk(tool_calls, request_id) unless Array(tool_calls).empty?
+            unless Array(tool_calls).empty?
+              return build_tool_call_chunk(tool_calls, request_id,
+                                           stop_reason: chunk_stop_reason, usage: chunk_usage)
+            end
 
             # Thinking delta
             thinking_content = message[:thinking] || message['thinking']
             unless thinking_content.to_s.empty?
               return Canonical::Chunk.thinking_delta(
                 delta: thinking_content.to_s,
-                request_id: request_id
+                request_id: request_id,
+                stop_reason: chunk_stop_reason,
+                usage: chunk_usage
               )
             end
 
@@ -438,7 +443,9 @@ module Legion
             unless content.to_s.empty?
               return Canonical::Chunk.text_delta(
                 delta: content.to_s,
-                request_id: request_id
+                request_id: request_id,
+                stop_reason: chunk_stop_reason,
+                usage: chunk_usage
               )
             end
 
@@ -448,20 +455,22 @@ module Legion
             nil
           end
 
-          def build_done_chunk(data, done_reason, request_id)
-            usage = Canonical::Usage.from_hash({
-                                                 input_tokens: data[:prompt_eval_count] || data['prompt_eval_count'],
-                                                 output_tokens: data[:eval_count] || data['eval_count']
-                                               })
+          def build_chunk_usage(data)
+            Canonical::Usage.from_hash({
+                                         input_tokens: data[:prompt_eval_count] || data['prompt_eval_count'],
+                                         output_tokens: data[:eval_count] || data['eval_count']
+                                       })
+          end
 
+          def build_done_chunk(data, done_reason, request_id)
             Canonical::Chunk.done(
               request_id: request_id,
-              usage: usage,
+              usage: build_chunk_usage(data),
               stop_reason: map_stop_reason(done_reason, true)
             )
           end
 
-          def build_tool_call_chunk(tool_calls, request_id)
+          def build_tool_call_chunk(tool_calls, request_id, stop_reason: nil, usage: nil)
             first_call = tool_calls.first
             first_call = first_call.transform_keys(&:to_sym) if first_call.is_a?(Hash)
             function = first_call[:function] || first_call['function'] || {}
@@ -476,7 +485,9 @@ module Legion
 
             Canonical::Chunk.tool_call_delta(
               tool_call: tc,
-              request_id: request_id
+              request_id: request_id,
+              stop_reason: stop_reason,
+              usage: usage
             )
           end
 

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Ollama
-        VERSION = '0.2.17'
+        VERSION = '0.2.24'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-ollama
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.24
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.9
 description: Ollama provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com