lex-llm-ollama 0.2.14 → 0.2.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bbec813c20e8b5c62b97209466439569cfcde42251acfe9e87f2bb0fce79e9d
-  data.tar.gz: 59822c6527476ec0000af57ec2a5884672d03065ca3212e0fb655faf809cc0da
+  metadata.gz: 9105e1f109fd5c83078224391ceb669ea321943a2075d85d5a77cf48b73d16e7
+  data.tar.gz: 1bd18adb284f8b8fa5c12e0049f310973989efb5a20070dcbb172754f64f941b
 SHA512:
-  metadata.gz: 6f41591f42a566ab7f3344e6d9963393db977dfea257b61c4a4aea798943804cc1db9f9525522cb690e5ab0448bc4b1451ee2ec3a67b615caccb049e84607bc4
-  data.tar.gz: effc50944c4583c1732ea4b23563c2f1ac00f660c0571e6c001403f3a140027303fe3bd77d2e0e64c61db39828a5230f9a35f30e7a1ab8663a3dd4e8b56bc185
+  metadata.gz: 175570e4fdf0574998741b731718675d643f03c1163183bd41a28a7c90151c71919150060c9d87ff27840f0bcf5203b90dba85e81680f1ec74d3f494b22c85f0
+  data.tar.gz: 9ebb03d6cdf2078303f8ac674cfe939a73770a0ce7b721e86c6daaeb63169c0039dfca9e7063138e83896322820939b203f68265da9a2125066ee4e05ecefcd4

data/.rubocop.yml

@@ -22,6 +22,12 @@ Metrics/CyclomaticComplexity:
   Enabled: false
 Metrics/PerceivedComplexity:
   Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Lint/DuplicateBranch:
+  Enabled: false
+Lint/UselessConstantScoping:
+  Enabled: false
 RSpec/MultipleExpectations:
   Enabled: false
 RSpec/ExampleLength:
@@ -32,3 +38,5 @@ RSpec/InstanceVariable:
   Enabled: false
 Style/Documentation:
   Enabled: false
+Style/AsciiComments:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [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
+
+## 0.2.16 - 2026-06-15
+
+- **CapabilityPolicy integration** — Optional capabilities default false; API-provided capabilities tagged as `:model_metadata`. Settings overrides at provider/instance/model level supported.
+
+## 0.2.15 - 2026-06-13
+
+- **Gemfile cleanup** — Remove local path overrides; dependencies resolve from gemspec via rubygems.
+- **Canonical tool support** — Use `ToolSchema.extract`, add `:tools` capability, canonical normalization for tool parameter schemas.
+- 147 examples, 0 failures; 17 files, 0 rubocop offenses.
+
 ## 0.2.14 - 2026-06-05
 
 - Verified specs and RuboCop compliance (52 examples, 0 failures; 15 files, 0 offenses)

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-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.4.3'
+  spec.add_dependency 'lex-llm', '>= 0.6.0'
 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

@@ -8,7 +8,7 @@ module Legion
     module Llm
       module Ollama
         # Ollama provider implementation for the Legion::Extensions::Llm base provider contract.
-        class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
+        class Provider < Legion::Extensions::Llm::Provider
           include Legion::Logging::Helper
 
           class << self
@@ -41,6 +41,10 @@ module Legion
             Ollama.default_settings
           end
 
+          def translator
+            @translator ||= Translator.new(config: config)
+          end
+
           def api_base
             resolve_base_url || normalize_url(settings[:base_url] || settings[:endpoint] || 'http://127.0.0.1:11434')
           end
@@ -73,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
@@ -108,24 +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
-            offerings = resolve_models(live).filter_map do |model_info|
-              next unless model_allowed?(model_info.id)
+          private
 
-              offering_from_model(model_info)
+          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 = {
@@ -149,8 +184,6 @@ module Legion
             'bge' => 512
           }.freeze
 
-          private
-
           def resolve_models(live)
             if live
               @cached_models = list_models
@@ -159,7 +192,26 @@ module Legion
             end
           end
 
-          def offering_from_model(model_info)
+          def running_model_ids
+            Array(list_running_models).filter_map do |m|
+              m['name'] || m[:name] || m['model'] || m[:model]
+            end.map(&:to_s)
+          end
+
+          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,
@@ -167,18 +219,35 @@ module Legion
               tier: offering_tier,
               model: model_info.id,
               usage_type: offering_usage_type(model_info),
-              capabilities: offering_capabilities(model_info),
+              capabilities: capabilities,
+              capability_sources: capability_sources,
               limits: offering_limits(model_info),
-              metadata: offering_metadata(model_info)
+              metadata: offering_metadata(model_info).merge(loaded: loaded)
             )
           end
 
-          def offering_usage_type(model_info)
-            model_info.embedding? ? :embedding : :inference
+          def resolve_capability_policy(model_info)
+            model_id = model_info.id.to_s
+            Legion::Extensions::Llm::CapabilityPolicy.resolve(
+              real: capabilities_from_api(model_info),
+              provider_catalog: {},
+              probe: {},
+              provider_envelope: { streaming: true },
+              provider_config: provider_capability_config,
+              instance_config: instance_capability_config,
+              model_config: model_capability_config(model_id)
+            )
+          end
+
+          def capabilities_from_api(model_info)
+            Array(model_info.capabilities).each_with_object({}) do |cap, hash|
+              sym = cap.to_s.downcase.to_sym
+              hash[sym] = true
+            end
           end
 
-          def offering_capabilities(model_info)
-            model_info.capabilities.map(&:to_s)
+          def offering_usage_type(model_info)
+            model_info.embedding? ? :embedding : :inference
           end
 
           def offering_limits(model_info)
@@ -294,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)
@@ -357,16 +426,16 @@ module Legion
           def format_tools(tools)
             return nil if tools.empty?
 
-            tool_names = tools.values.filter_map { |tool| tool.respond_to?(:name) ? tool.name : nil }
+            tool_names = tools.values.filter_map { |tool| Legion::Extensions::Llm::Canonical::ToolSchema.tool_name(tool) }
             log.debug { "ollama provider formatting tools count=#{tools.size} names=#{tool_names.join(',')}" }
 
             tools.values.map do |tool|
               {
                 type: 'function',
                 function: {
-                  name: tool.name,
-                  description: tool.description,
-                  parameters: tool.params_schema || { type: 'object', properties: {} }
+                  name: Legion::Extensions::Llm::Canonical::ToolSchema.tool_name(tool),
+                  description: Legion::Extensions::Llm::Canonical::ToolSchema.tool_description(tool),
+                  parameters: Legion::Extensions::Llm::Canonical::ToolSchema.extract(tool)
                 }
               }
             end
@@ -380,67 +449,74 @@ module Legion
 
           def parse_completion_response(response)
             body = response.body
-            message = body.fetch('message', {})
-            content, thinking = extract_thinking_from_completion(message)
+            canonical = translator.parse_response(body)
+            to_legacy_message(canonical, body)
+          end
+
+          def build_chunk(data)
+            canonical_chunk = translator.parse_chunk(data)
+            return nil if canonical_chunk.nil?
+
+            to_legacy_chunk(canonical_chunk, data)
+          end
+
+          def to_legacy_message(canonical, raw_body)
+            usage = canonical.usage
             Legion::Extensions::Llm::Message.new(
               role: :assistant,
-              content: content,
-              model_id: body['model'],
-              tool_calls: parse_tool_calls(message['tool_calls']),
-              thinking: thinking,
-              input_tokens: body['prompt_eval_count'],
-              output_tokens: body['eval_count'],
-              raw: body
+              content: canonical.text,
+              model_id: canonical.model,
+              thinking: if canonical.thinking
+                          Legion::Extensions::Llm::Thinking.build(
+                            text: canonical.thinking.content, signature: canonical.thinking.signature
+                          )
+                        end,
+              tool_calls: legacy_tool_calls(canonical.tool_calls),
+              input_tokens: usage&.input_tokens,
+              output_tokens: usage&.output_tokens,
+              raw: raw_body
             )
           end
 
-          def build_chunk(data)
-            message = data.fetch('message', {})
-            thinking = message['thinking']
+          def to_legacy_chunk(canonical_chunk, raw_data)
             Legion::Extensions::Llm::Chunk.new(
               role: :assistant,
-              content: message['content'],
-              thinking: thinking ? Thinking.build(text: thinking) : nil,
-              tool_calls: parse_tool_calls(message['tool_calls']),
-              model_id: data['model'],
-              input_tokens: data['prompt_eval_count'],
-              output_tokens: data['eval_count'],
-              raw: data
+              content: canonical_chunk.text_delta? ? canonical_chunk.delta : nil,
+              thinking: if canonical_chunk.thinking_delta?
+                          Legion::Extensions::Llm::Thinking.build(
+                            text: canonical_chunk.delta
+                          )
+                        end,
+              tool_calls: legacy_streaming_tool_calls(canonical_chunk),
+              model_id: raw_data['model'] || raw_data[:model],
+              input_tokens: canonical_chunk.usage&.input_tokens ||
+                             raw_data['prompt_eval_count'] || raw_data[:prompt_eval_count],
+              output_tokens: canonical_chunk.usage&.output_tokens ||
+                              raw_data['eval_count'] || raw_data[:eval_count],
+              raw: raw_data
             )
           end
 
-          def extract_thinking_from_completion(message)
-            extraction = Responses::ThinkingExtractor.extract(
-              message['content'],
-              metadata: thinking_metadata(message)
-            )
-
-            [
-              extraction.content,
-              Thinking.build(text: extraction.thinking, signature: extraction.signature)
-            ]
-          end
+          def legacy_tool_calls(canonical_tool_calls)
+            return nil if canonical_tool_calls.nil? || canonical_tool_calls.empty?
 
-          def thinking_metadata(message)
-            { thinking: message['thinking'] }.compact
+            canonical_tool_calls.to_h do |tc|
+              [
+                (tc.name || tc.id).to_s.to_sym,
+                Legion::Extensions::Llm::ToolCall.new(id: tc.id, name: tc.name, arguments: tc.arguments || {})
+              ]
+            end
           end
 
-          def parse_tool_calls(tool_calls)
-            return nil unless tool_calls
+          def legacy_streaming_tool_calls(canonical_chunk)
+            return nil unless canonical_chunk.tool_call_delta?
 
-            log.debug { "ollama provider parsing tool_call_count=#{tool_calls.size}" }
+            tc = canonical_chunk.tool_call
+            return nil unless tc
 
-            tool_calls.to_h do |call|
-              function = call.fetch('function', {})
-              [
-                function.fetch('name').to_sym,
-                Legion::Extensions::Llm::ToolCall.new(
-                  id: call['id'] || function['name'],
-                  name: function['name'],
-                  arguments: function['arguments'] || {}
-                )
-              ]
-            end
+            { (tc.name || tc.id).to_s.to_sym => Legion::Extensions::Llm::ToolCall.new(
+              id: tc.id, name: tc.name, arguments: tc.arguments || ''
+            ) }
           end
 
           def parse_list_models_response(response, provider, _capabilities)

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

@@ -0,0 +1,497 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/canonical'
+require 'legion/extensions/llm/responses/thinking_extractor'
+require 'legion/json'
+require 'legion/logging'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ollama
+        # Canonical provider translator for Ollama (/api/chat NDJSON wire format).
+        #
+        # Implements render_request, parse_response, parse_chunk, and capabilities.
+        # Ollama uses NDJSON streaming (not SSE), native tool calling, and the `think`
+        # flag for extended thinking support.
+        #
+        # Ollama quirks (declared in capabilities):
+        # - tool_calls_as_text: false — Ollama returns structured tool_calls natively.
+        # - forced_tool_choice: false — Ollama does not support forced tool selection.
+        # - assistant_prefill: false — Ollama does not support assistant prefill.
+        class Translator
+          include Legion::Logging::Helper
+
+          # 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.
+          PARAM_OPTIONS_KEYS = {
+            max_tokens: :num_predict,
+            temperature: :temperature,
+            top_p: :top_p,
+            top_k: :top_k,
+            stop_sequences: :stop,
+            seed: :seed,
+            frequency_penalty: :frequency_penalty,
+            presence_penalty: :presence_penalty
+          }.freeze
+
+          SUPPORTED_PARAMS = %i[
+            max_tokens temperature top_p top_k stop_sequences
+            seed frequency_penalty presence_penalty
+          ].freeze
+
+          def initialize(config: nil)
+            @config = config
+          end
+
+          # Render a canonical request into Ollama /api/chat wire payload.
+          def render_request(request)
+            model = request.metadata&.dig(:model) || 'default'
+            messages = format_messages(request)
+            payload = {
+              model: model,
+              messages: messages,
+              stream: request.stream
+            }
+
+            payload[:tools] = format_tools(request.tools) unless request.tools.to_h.empty?
+            apply_options(payload, request.params)
+            apply_thinking_config(payload, request)
+            apply_response_format(payload, request.params)
+
+            log.debug do
+              "[llm][ollama-translator] action=render_request model=#{model} stream=#{request.stream} " \
+                "message_count=#{messages.size} tools=#{request.tools&.size || 0}"
+            end
+
+            payload.compact
+          end
+
+          # Parse an Ollama /api/chat completion response into a Canonical::Response.
+          def parse_response(wire)
+            return canonical_error_response(wire) unless wire.is_a?(Hash)
+            return Canonical::Response.from_hash(wire) if canonical_response?(wire)
+
+            message = wire[:message] || wire['message'] || {}
+            content = message[:content] || message['content'] || ''
+            tool_calls_raw = message[:tool_calls] || message['tool_calls']
+            model = wire[:model] || wire['model']
+            done_reason = wire[:done_reason] || wire['done_reason']
+            done = wire[:done] || wire['done']
+
+            extraction = Responses::ThinkingExtractor.extract(
+              content,
+              metadata: thinking_metadata(message)
+            )
+
+            text = extraction.content || ''
+            thinking = build_canonical_thinking(extraction)
+            tool_calls = parse_tool_calls(tool_calls_raw)
+            stop_reason = map_stop_reason(done_reason, done)
+
+            usage = Canonical::Usage.from_hash({
+                                                 input_tokens: wire[:prompt_eval_count] || wire['prompt_eval_count'],
+                                                 output_tokens: wire[:eval_count] || wire['eval_count']
+                                               })
+
+            Canonical::Response.build(
+              text: text.to_s,
+              thinking: thinking,
+              tool_calls: tool_calls,
+              usage: usage,
+              stop_reason: stop_reason,
+              model: model,
+              metadata: {}
+            )
+          rescue StandardError => e
+            handle_exception(e, level: :error, handled: false, operation: 'ollama.translator.parse_response')
+            raise
+          end
+
+          # Parse a single NDJSON chunk into a Canonical::Chunk or nil.
+          def parse_chunk(raw)
+            return nil if raw.nil?
+
+            data = normalize_chunk_input(raw)
+            return nil if data.nil?
+
+            # Handle canonical-form chunks (from conformance fixtures)
+            return handle_canonical_chunk(data) if data['type'] || data[:type]
+
+            parse_ollama_chunk(data)
+          rescue StandardError => e
+            handle_exception(e, level: :error, handled: false, operation: 'ollama.translator.parse_chunk')
+            raise
+          end
+
+          # Declared capabilities for the Ollama provider.
+          def capabilities
+            {
+              provider: 'ollama',
+              streaming: true,
+              tool_calls: true,
+              thinking: true,
+              vision: true,
+              embeddings: true,
+              tool_calls_as_text: false,
+              forced_tool_choice: false,
+              assistant_prefill: false
+            }.freeze
+          end
+
+          private
+
+          attr_reader :config
+
+          # -- Message formatting --
+
+          def format_messages(request)
+            messages = format_request_messages(request.messages)
+
+            if request.system.to_s.strip.empty?
+              messages
+            else
+              [{ role: 'system', content: request.system.strip }] + messages
+            end
+          end
+
+          def format_request_messages(messages)
+            return [] if messages.nil? || messages.empty?
+
+            messages.map { |msg| format_message(msg) }
+          end
+
+          def format_message(msg)
+            role = msg.role.to_s
+            content = format_message_content(msg)
+            result = { role: role, content: content }
+
+            images = extract_images(msg.content)
+            result[:images] = images unless images.empty?
+
+            result[:tool_call_id] = msg.tool_call_id if msg.tool_call_id
+            result.compact
+          end
+
+          def format_message_content(msg)
+            content = msg.content
+            return content if content.is_a?(String)
+
+            case content
+            when Array
+              extract_text_from_blocks(content)
+            when Canonical::ContentBlock
+              content.text? ? content.text.to_s : content.to_s
+            else
+              content.to_s
+            end
+          end
+
+          def extract_text_from_blocks(blocks)
+            parts = blocks.filter_map do |block|
+              case block
+              when Canonical::ContentBlock
+                format_content_block_text(block)
+              when Hash
+                block_hash = block.transform_keys(&:to_sym)
+                block_hash[:text]&.to_s
+              else
+                block.to_s
+              end
+            end
+            parts.join
+          end
+
+          def format_content_block_text(block)
+            case block.type
+            when :text, :thinking
+              block.text.to_s
+            when :tool_use
+              Legion::JSON.dump({ name: block.name, arguments: block.input || {} })
+            when :tool_result
+              block.text.to_s
+            end
+          end
+
+          def extract_images(content)
+            return [] unless content.is_a?(Array)
+
+            content.filter_map do |block|
+              next unless block.is_a?(Canonical::ContentBlock) && block.type == :image
+
+              block.data
+            end
+          end
+
+          # -- Tool formatting --
+
+          def format_tools(tools)
+            return nil if tools.to_h.empty?
+
+            tools.to_h.values.map do |tool|
+              tool_hash = if tool.is_a?(Canonical::ToolDefinition)
+                            { name: tool.name, description: tool.description, parameters: tool.parameters }
+                          elsif tool.is_a?(Hash)
+                            tool.transform_keys(&:to_sym)
+                          else
+                            tool
+                          end
+
+              name = tool_hash[:name] || tool_hash['name']
+              description = (tool_hash[:description] || tool_hash['description'] || '').to_s
+              raw_params = tool_hash[:parameters] || tool_hash[:input_schema]
+              raw_params = raw_params.to_h if raw_params.respond_to?(:to_h) && !raw_params.is_a?(Hash)
+              parameters = Legion::Extensions::Llm::Canonical::ToolDefinition.normalize_parameters(raw_params)
+
+              {
+                type: 'function',
+                function: {
+                  name: name.to_s,
+                  description: description,
+                  parameters: parameters
+                }
+              }
+            end
+          end
+
+          # -- Parameter mapping (G18) --
+
+          def apply_options(payload, params)
+            return unless params.is_a?(Canonical::Params)
+
+            options = {}
+            SUPPORTED_PARAMS.each do |param_key|
+              value = params.public_send(param_key)
+              next if value.nil?
+
+              wire_key = PARAM_OPTIONS_KEYS[param_key]
+              options[wire_key] = case param_key
+                                  when :stop_sequences
+                                    Array(value)
+                                  else
+                                    value
+                                  end
+            end
+
+            payload[:options] = options unless options.empty?
+
+            return unless params.max_thinking_tokens
+
+            log.debug do
+              '[llm][ollama-translator] action=drop_unsupported_param param=max_thinking_tokens ' \
+                "value=#{params.max_thinking_tokens} reason=ollama_not_supported"
+            end
+          end
+
+          # -- Thinking configuration --
+
+          def apply_thinking_config(payload, request)
+            return unless enable_thinking?(request)
+
+            payload[:think] = true
+          end
+
+          def enable_thinking?(request)
+            return true if request.thinking.is_a?(Canonical::Thinking::Config) && request.thinking.enabled?
+            return true if request.thinking.is_a?(Hash) && (request.thinking[:enabled] != false)
+
+            false
+          end
+
+          # -- Response format --
+
+          def apply_response_format(payload, params)
+            return unless params.is_a?(Canonical::Params) && params.response_format
+
+            format_value = params.response_format
+            payload[:format] = if format_value.is_a?(Hash)
+                                 schema = format_value[:schema] || format_value['schema'] ||
+                                          format_value[:json_schema] || format_value['json_schema']
+                                 schema || format_value
+                               else
+                                 format_value
+                               end
+          end
+
+          # -- Response parsing --
+
+          def canonical_response?(wire)
+            wire.key?(:text) || wire.key?('text') || wire.key?(:stop_reason) || wire.key?('stop_reason')
+          end
+
+          def canonical_error_response(wire)
+            body = wire.is_a?(Hash) ? wire : {}
+            error_info = body['error'] || body[:error] ||
+                         { type: 'parse_error', message: 'Failed to parse response' }
+
+            Canonical::Response.build(
+              text: '',
+              tool_calls: [],
+              usage: Canonical::Usage.from_hash(body['usage'] || body[:usage] || {}),
+              stop_reason: :error,
+              model: body['model'] || body[:model],
+              metadata: { error: error_info }
+            )
+          end
+
+          def thinking_metadata(message)
+            thinking = message[:thinking] || message['thinking']
+            return {} unless thinking
+
+            { thinking: thinking }
+          end
+
+          def build_canonical_thinking(extraction)
+            return nil unless extraction.thinking || extraction.signature
+
+            Canonical::Thinking.new(
+              content: extraction.thinking,
+              signature: extraction.signature
+            )
+          end
+
+          def parse_tool_calls(tool_calls_raw)
+            return [] unless tool_calls_raw.is_a?(Array) && !tool_calls_raw.empty?
+
+            tool_calls_raw.filter_map do |call|
+              call = call.transform_keys(&:to_sym) if call.is_a?(Hash)
+              function = call[:function] || call['function'] || {}
+              function = function.transform_keys(&:to_sym) if function.is_a?(Hash)
+
+              name = function[:name] || function['name']
+              id = call[:id] || call['id'] || name
+              args = parse_tool_arguments(function[:arguments] || function['arguments'])
+
+              Canonical::ToolCall.build(
+                id: id.to_s,
+                name: name.to_s,
+                arguments: args,
+                source: :client
+              )
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'ollama.translator.parse_tool_call')
+              nil
+            end
+          end
+
+          def parse_tool_arguments(arguments)
+            return {} if arguments.nil? || arguments == ''
+            return arguments if arguments.is_a?(Hash)
+
+            Legion::JSON.load(arguments)
+          rescue Legion::JSON::ParseError
+            {}
+          end
+
+          def map_stop_reason(done_reason, done = nil)
+            if done_reason
+              OLLAMA_STOP_REASON_MAP.fetch(done_reason.to_s, FALLBACK_STOP_REASON)
+            elsif done
+              FALLBACK_STOP_REASON
+            end
+          end
+
+          # -- Chunk parsing --
+
+          def normalize_chunk_input(raw)
+            return nil if raw.is_a?(String) && raw.strip.empty?
+
+            raw.is_a?(Hash) ? raw : parse_json_safely(raw)
+          end
+
+          def handle_canonical_chunk(data)
+            normalized = data.is_a?(Hash) && data.keys.first.is_a?(Symbol) ? data : data.transform_keys(&:to_sym)
+            Canonical::Chunk.from_hash(normalized)
+          rescue StandardError => e
+            log.debug { "[llm][ollama-translator] action=canonical_chunk_parse_error error=#{e.message}" }
+            nil
+          end
+
+          def parse_ollama_chunk(data)
+            message = data[:message] || data['message'] || {}
+            done = data[:done] || data['done']
+            done_reason = data[:done_reason] || data['done_reason']
+            request_id = data[:request_id] || data['request_id'] || data[:id] || data['id']
+
+            # 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?
+
+            # 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
+              )
+            end
+
+            # Text delta — emit content even on done chunks (Ollama's final chunk may carry text)
+            content = message[:content] || message['content']
+            unless content.to_s.empty?
+              return Canonical::Chunk.text_delta(
+                delta: content.to_s,
+                request_id: request_id
+              )
+            end
+
+            # Done chunk (only when no content/thinking/tool_calls to emit)
+            return build_done_chunk(data, done_reason, request_id) if done
+
+            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']
+                                               })
+
+            Canonical::Chunk.done(
+              request_id: request_id,
+              usage: usage,
+              stop_reason: map_stop_reason(done_reason, true)
+            )
+          end
+
+          def build_tool_call_chunk(tool_calls, request_id)
+            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'] || {}
+            function = function.transform_keys(&:to_sym) if function.is_a?(Hash)
+
+            tc = Canonical::ToolCall.build(
+              id: (first_call[:id] || first_call['id'] || function[:name] || 'synthesized').to_s,
+              name: (function[:name] || function['name']).to_s,
+              arguments: parse_tool_arguments(function[:arguments] || function['arguments']),
+              source: :client
+            )
+
+            Canonical::Chunk.tool_call_delta(
+              tool_call: tc,
+              request_id: request_id
+            )
+          end
+
+          # -- JSON helpers --
+
+          def parse_json_safely(raw)
+            return nil unless raw.is_a?(String)
+
+            Legion::JSON.load(raw)
+          rescue Legion::JSON::ParseError => e
+            log.debug { "[llm][ollama-translator] action=json_parse_error error=#{e.message}" }
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Ollama
-        VERSION = '0.2.14'
+        VERSION = '0.2.22'
       end
     end
   end

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

@@ -2,8 +2,10 @@
 
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/ollama/provider'
+require 'legion/extensions/llm/ollama/translator'
 require 'legion/extensions/llm/ollama/version'
 require 'legion/logging/helper'
+require_relative 'ollama/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -30,10 +32,7 @@ module Legion
               fleet: {
                 enabled: false,
                 respond_to_requests: false,
-                capabilities: %i[chat stream_chat embed],
-                lanes: [],
-                concurrency: 1,
-                queue_suffix: nil
+                capabilities: %i[chat stream_chat embed tools]
               }
             }
           )
@@ -73,7 +72,8 @@ module Legion
           instances[:local] = {
             base_url: 'http://127.0.0.1:11434',
             tier: :local,
-            capabilities: %i[completion embedding vision]
+            capabilities: {},
+            provider_capabilities: { streaming: true }
           }
         end
 
@@ -85,7 +85,8 @@ module Legion
           configured.each do |name, config|
             instances[name.to_sym] = normalize_instance_config(config).merge(
               tier: :direct,
-              capabilities: %i[completion embedding vision]
+              capabilities: {},
+              provider_capabilities: { streaming: true }
             )
           end
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-ollama
 version: !ruby/object:Gem::Version
-  version: 0.2.14
+  version: 0.2.22
 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: Ollama provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -101,6 +101,7 @@ files:
 - lib/legion/extensions/llm/ollama/actors/fleet_worker.rb
 - lib/legion/extensions/llm/ollama/provider.rb
 - lib/legion/extensions/llm/ollama/runners/fleet_worker.rb
+- lib/legion/extensions/llm/ollama/translator.rb
 - lib/legion/extensions/llm/ollama/version.rb
 homepage: https://github.com/LegionIO/lex-llm-ollama
 licenses: