lex-llm-ollama 0.2.10 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 367e593d0f98eed36e553e82356f0c86e37dd8e4a1324674c388f0383e59034d
-  data.tar.gz: f9d24ec554a9be7be90d33c76ddbb7d475a976c8158ceda71f596fcc8bfa42dd
+  metadata.gz: ae0169129db1cf8833dcbc252f5b06b6c3ed6e2ab106a262b9dc90789919da55
+  data.tar.gz: f8af5ef3ccea0f79638bbdf77dfb43392cc7332a602aedbc01a2514e229d8e03
 SHA512:
-  metadata.gz: 5be0235ede9a88b3b355cd2d6232c885332f6bcf8f5e0041922d496a76b5335c1533edd193b50c8ffe1f04953305b6527d7c60ac1a46b8d35d9cf28535902c36
-  data.tar.gz: cce2dd847b6fa13f1c8bf2c2a84df522315ed1d8af2f0e524e0564309a24494b4336432a57c60e3b2570402354923f1de805c7d721131d30939e633624f8aa4e
+  metadata.gz: 208c7d4cd46c681bffd89ff263378beb2460af6e27554ca79c04e2850771bd69b9722e3fc547093af2dc20332ee29e17da72363aab8e92b435f1b93d3615a77f
+  data.tar.gz: 92333b402f15d5eb694a747a45cb6b37289d6d2d6fc43dcb2784647e59c12c4eca2b959491f3fe4d567f4b134f8a37d4589be7b76b3ad887b1630bcaa46662cc

data/.rubocop.yml

@@ -14,5 +14,21 @@ Metrics/BlockLength:
     - spec/**/*
 Metrics/MethodLength:
   Enabled: false
+Metrics/ParameterLists:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
 RSpec/MultipleExpectations:
   Enabled: false
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/LeakyConstantDeclaration:
+  Enabled: false
+RSpec/InstanceVariable:
+  Enabled: false
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.2.12 - 2026-05-21
+
+- Add `default_transport`/`default_tier` class declarations, remove duplicate instance methods
+- Add `model_allowed?` filtering in `discover_offerings`
+- Add `DiscoveryRefresh` actor (Every, 30min, run_now) for non-blocking model discovery
+- Identity headers included via base provider
+- api_base reads from settings[:endpoint] fallback
+
+
 ## 0.2.10 - 2026-05-16
 
 - Stop assuming every non-embedding Ollama model supports tools; fallback chat discovery now advertises completion, streaming, and vision only.

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+begin
+  require 'legion/extensions/actors/every'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
+return unless defined?(Legion::Extensions::Actors::Every)
+
+module Legion
+  module Extensions
+    module Llm
+      module Ollama
+        module Actor
+          class DiscoveryRefresh < Legion::Extensions::Actors::Every
+            include Legion::Logging::Helper
+
+            REFRESH_INTERVAL = 1800
+
+            def runner_class    = self.class
+            def runner_function = 'manual'
+            def run_now?        = true
+            def use_runner?     = false
+            def check_subtask?  = false
+            def generate_task?  = false
+
+            def time
+              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+
+              Legion::Settings.dig(:extensions, :llm, :ollama, :discovery_interval) || REFRESH_INTERVAL
+            end
+
+            def manual
+              log.debug('[ollama][discovery_refresh] refreshing model list')
+              return unless defined?(Legion::LLM::Discovery)
+
+              Legion::LLM::Discovery.run
+              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!
+              end
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'ollama.actor.discovery_refresh')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,8 @@ module Legion
 
             def slug = 'ollama'
             def local? = true
+            def default_transport = :http
+            def default_tier = :local
             def configuration_requirements = []
             def capabilities = Capabilities
 
@@ -40,7 +42,7 @@ module Legion
           end
 
           def api_base
-            resolve_base_url || normalize_url(settings[:base_url] || '127.0.0.1:11434')
+            resolve_base_url || normalize_url(settings[:base_url] || settings[:endpoint] || 'http://127.0.0.1:11434')
           end
 
           def config_base_url
@@ -110,9 +112,13 @@ module Legion
             log.debug do
               "ollama provider discovering offerings live=#{live} cached_model_count=#{Array(@cached_models).size}"
             end
-            resolve_models(live).map { |model_info| offering_from_model(model_info) }.tap do |offerings|
-              log.debug { "ollama provider built offering_count=#{offerings.size} live=#{live}" }
+            offerings = resolve_models(live).filter_map do |model_info|
+              next unless model_allowed?(model_info.id)
+
+              offering_from_model(model_info)
             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}")
             []
@@ -167,14 +173,6 @@ module Legion
             )
           end
 
-          def offering_transport
-            config.respond_to?(:transport) ? config.transport : :http
-          end
-
-          def offering_tier
-            config.respond_to?(:tier) ? config.tier : :local
-          end
-
           def offering_usage_type(model_info)
             model_info.embedding? ? :embedding : :inference
           end
@@ -238,7 +236,7 @@ module Legion
             settings[:keep_alive]
           end
 
-          def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:) # rubocop:disable Metrics/ParameterLists
+          def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:)
             model_id = model.respond_to?(:id) ? model.id : model
             log.debug do
               "ollama provider rendering chat payload model=#{model_id} message_count=#{messages.size} " \
@@ -249,7 +247,7 @@ module Legion
               model: model_id,
               messages: format_messages(messages),
               stream: stream,
-              think: thinking ? true : nil,
+              think: thinking == true,
               keep_alive: ollama_keep_alive,
               format: schema_format(schema),
               options: { temperature: temperature }.compact,
@@ -258,6 +256,77 @@ module Legion
             }.compact
           end
 
+          def stream_response(connection, payload, additional_headers = {}, &block)
+            buffer = +''
+            chunks = []
+
+            connection.post(stream_url, payload) do |req|
+              req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
+              req.options.on_data = ndjson_handler(buffer, chunks, block)
+            end
+
+            finalize_stream(chunks)
+          end
+
+          def ndjson_handler(buffer, chunks, block)
+            proc do |chunk_data, _bytes, env|
+              next if env.respond_to?(:status) && env.status && env.status != 200
+
+              buffer << chunk_data.to_s
+              drain_ndjson_buffer(buffer, chunks, block)
+            end
+          end
+
+          def drain_ndjson_buffer(buffer, chunks, block)
+            while (idx = buffer.index("\n"))
+              line = buffer.slice!(0..idx).strip
+              next if line.empty?
+
+              parse_ndjson_line(line, chunks, block)
+            end
+          end
+
+          def parse_ndjson_line(line, chunks, block)
+            parsed = Legion::JSON.parse(line, symbolize_names: false)
+            return unless parsed.is_a?(Hash)
+
+            built = build_chunk(parsed)
+            chunks << built
+            block&.call(built)
+          rescue Legion::JSON::ParseError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'ollama.stream_parse')
+          end
+
+          def finalize_stream(chunks)
+            return Legion::Extensions::Llm::Message.new(role: :assistant, content: nil) if chunks.empty?
+
+            Legion::Extensions::Llm::Message.new(
+              role: :assistant,
+              content: join_stream_content(chunks),
+              thinking: join_stream_thinking(chunks),
+              tool_calls: merge_stream_tool_calls(chunks),
+              model_id: chunks.last.model_id,
+              input_tokens: chunks.last.input_tokens,
+              output_tokens: chunks.last.output_tokens,
+              raw: chunks.last.raw
+            )
+          end
+
+          def join_stream_content(chunks)
+            text = chunks.filter_map { |c| c.content&.to_s }.join
+            text.empty? ? nil : text
+          end
+
+          def join_stream_thinking(chunks)
+            parts = chunks.filter_map { |c| c.thinking&.text }
+            Thinking.build(text: parts.empty? ? nil : parts.join)
+          end
+
+          def merge_stream_tool_calls(chunks)
+            merged = chunks.filter_map(&:tool_calls).reject(&:empty?).reduce({}, :merge)
+            merged.empty? ? nil : merged
+          end
+
           def format_messages(messages)
             messages.map do |message|
               content = message.content
@@ -312,11 +381,13 @@ module Legion
           def parse_completion_response(response)
             body = response.body
             message = body.fetch('message', {})
+            content, thinking = extract_thinking_from_completion(message)
             Legion::Extensions::Llm::Message.new(
               role: :assistant,
-              content: message['content'],
+              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
@@ -325,9 +396,12 @@ module Legion
 
           def build_chunk(data)
             message = data.fetch('message', {})
+            thinking = message['thinking']
             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'],
@@ -335,6 +409,22 @@ module Legion
             )
           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 thinking_metadata(message)
+            { thinking: message['thinking'] }.compact
+          end
+
           def parse_tool_calls(tool_calls)
             return nil unless tool_calls
 

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Ollama
-        VERSION = '0.2.10'
+        VERSION = '0.2.12'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-ollama
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.12
 platform: ruby
 authors:
 - LegionIO
@@ -97,6 +97,7 @@ files:
 - README.md
 - lex-llm-ollama.gemspec
 - lib/legion/extensions/llm/ollama.rb
+- lib/legion/extensions/llm/ollama/actors/discovery_refresh.rb
 - 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