lex-llm-ollama 0.2.8 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20e5e1a5989633a805483200893d6d11c6f0af9b3d9b3204defad0e33e0be5ed
-  data.tar.gz: 8dd17ebb04df4e90b75438f8f4ba86bb289db4ccde25f1b71d36253a9075450c
+  metadata.gz: 367e593d0f98eed36e553e82356f0c86e37dd8e4a1324674c388f0383e59034d
+  data.tar.gz: f9d24ec554a9be7be90d33c76ddbb7d475a976c8158ceda71f596fcc8bfa42dd
 SHA512:
-  metadata.gz: '0944f1f288b824bcc09b9ca13e9ece5d67553fe4d706e26a7d77b37c1fa71c594eaeb8b0f2f8fd9817259463e9289257019b700a4a02019077f1c889e0b7aa8a'
-  data.tar.gz: 32c4de66b95c05e9b0349a2c1da79f826fd701fd9aa61d25957291076c3e6ca87fa79338fd323e652c1e441342bb54f6a1dc97b03bd5ffafe56c3eb32411eeb1
+  metadata.gz: 5be0235ede9a88b3b355cd2d6232c885332f6bcf8f5e0041922d496a76b5335c1533edd193b50c8ffe1f04953305b6527d7c60ac1a46b8d35d9cf28535902c36
+  data.tar.gz: cce2dd847b6fa13f1c8bf2c2a84df522315ed1d8af2f0e524e0564309a24494b4336432a57c60e3b2570402354923f1de805c7d721131d30939e633624f8aa4e

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 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.
+- Add canonical Ollama capability normalization so reported `tools`/function-calling metadata is preserved and streaming is inferred for chat/completion models.
+- Include reported capability metadata from `/api/show` model detail responses.
+
+## 0.2.9 - 2026-05-13
+
+- Add `fetch_model_detail` — calls POST `/api/show` to retrieve the real context window from Ollama.
+- Add `resolve_context_window` — tries live model detail cache first, falls back to static prefix map.
+- Add `extract_context_window` — parses `num_ctx` from `model_info` hash or `parameters` string in the `/api/show` response.
+- Add `CONTEXT_WINDOWS` static fallback map covering common Ollama model families.
+- Add `rescue Faraday::ConnectionFailed` in `discover_offerings` with a concise warn log instead of an unhandled exception.
+- Add `show_model_url` endpoint helper returning `/api/show`.
+
 ## 0.2.8 - 2026-05-12
 
 - Include `Legion::Logging::Helper` directly in Ollama provider, actor, and fleet runner runtime surfaces.

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

@@ -87,6 +87,16 @@ module Legion
             raise
           end
 
+          def fetch_model_detail(model_name)
+            raw = show_model(model_name)
+            context_window = extract_context_window(raw)
+            { context_window: context_window, capabilities: extract_capabilities(raw) }.compact
+          rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'ollama.fetch_model_detail',
+                                model: model_name)
+            nil
+          end
+
           def pull_model(model, stream: false)
             log.debug { "ollama provider pulling model=#{model} stream=#{stream}" }
             log.info { "pulling model #{model} stream=#{stream}" }
@@ -100,21 +110,49 @@ module Legion
             log.debug do
               "ollama provider discovering offerings live=#{live} cached_model_count=#{Array(@cached_models).size}"
             end
-            models = if live
-                       @cached_models = list_models
-                     else
-                       Array(@cached_models)
-                     end
-            models.map { |model_info| offering_from_model(model_info) }.tap do |offerings|
+            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}" }
             end
+          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')
+            handle_exception(e, level: :warn, handled: true, operation: 'ollama.discover_offerings',
+                                backtrace_limit: 3)
             []
           end
 
+          CONTEXT_WINDOWS = {
+            'qwen3' => 128_000,
+            'qwen2.5' => 128_000,
+            'llama3' => 128_000,
+            'llama3.1' => 128_000,
+            'llama3.2' => 128_000,
+            'llama3.3' => 128_000,
+            'gemma2' => 8_192,
+            'gemma3' => 128_000,
+            'mistral' => 128_000,
+            'deepseek' => 128_000,
+            'phi3' => 128_000,
+            'phi4' => 16_384,
+            'command-r' => 128_000,
+            'codellama' => 16_384,
+            'nomic-embed' => 8_192,
+            'mxbai-embed' => 512,
+            'snowflake' => 512,
+            'bge' => 512
+          }.freeze
+
           private
 
+          def resolve_models(live)
+            if live
+              @cached_models = list_models
+            else
+              Array(@cached_models)
+            end
+          end
+
           def offering_from_model(model_info)
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :ollama,
@@ -146,7 +184,46 @@ module Legion
           end
 
           def offering_limits(model_info)
-            { context_window: model_info.context_length }.compact
+            ctx = model_info.context_length || resolve_context_window(model_info.id)
+            ctx ? { context_window: ctx } : {}
+          end
+
+          def resolve_context_window(model_id)
+            detail = model_detail(model_id)
+            return detail[:context_window] if detail.is_a?(Hash) && detail[:context_window]
+
+            infer_context_window(model_id)
+          end
+
+          def infer_context_window(model_id)
+            name = model_id.to_s.split(':').first
+            CONTEXT_WINDOWS.find { |prefix, _| name.start_with?(prefix) }&.last
+          end
+
+          def extract_context_window(raw)
+            return nil unless raw.is_a?(Hash)
+
+            from_model_info(raw) || from_parameters_string(raw)
+          end
+
+          def from_model_info(raw)
+            model_info = raw['model_info'] || raw[:model_info]
+            return unless model_info.is_a?(Hash)
+
+            num_ctx_from_hash(model_info)&.to_i
+          end
+
+          def num_ctx_from_hash(model_info)
+            model_info['num_ctx'] || model_info[:num_ctx] ||
+              model_info.find { |k, _| k.to_s.end_with?('.context_length') }&.last
+          end
+
+          def from_parameters_string(raw)
+            params = raw['parameters'] || raw[:parameters]
+            return unless params.is_a?(String)
+
+            match = params.match(/num_ctx\s+(\d+)/)
+            match[1].to_i if match
           end
 
           def offering_metadata(model_info)
@@ -295,15 +372,35 @@ module Legion
           end
 
           def infer_capabilities(name, family, api_caps)
-            return api_caps.map(&:to_sym) unless api_caps.empty?
+            normalized = normalize_ollama_capabilities(api_caps)
+            return normalized unless normalized.empty?
 
             if embedding_model?(name, family)
               [:embedding]
             else
-              %i[completion streaming tools vision]
+              %i[completion streaming vision]
             end
           end
 
+          def normalize_ollama_capabilities(capabilities)
+            Array(capabilities).compact.each_with_object([]) do |capability, result|
+              capability_sym = capability.to_s.downcase.strip.to_sym
+              next if capability_sym.to_s.empty?
+
+              result << capability_sym
+              result << :tools if %i[function_calling functions tool tool_use].include?(capability_sym)
+              result << :streaming if %i[chat completion].include?(capability_sym)
+            end.uniq
+          end
+
+          def extract_capabilities(raw)
+            return nil unless raw.is_a?(Hash)
+
+            caps = raw['capabilities'] || raw[:capabilities]
+            normalized = normalize_ollama_capabilities(caps)
+            normalized unless normalized.empty?
+          end
+
           def embedding_model?(name, family)
             name.to_s.match?(/embed|embedding/i) || family.to_s.match?(/bert|nomic/i)
           end

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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-ollama
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.10
 platform: ruby
 authors:
 - LegionIO