lex-llm-ollama 0.2.9 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90c9bd5b9b740637320d528012401d93d38e1d0b38396c3baa51ad45067547aa
-  data.tar.gz: 1024e115de9bea52c58b3fb20bbbf1fc561bc6299f4bdfea4a95d2c7899618c8
+  metadata.gz: 98c1040c20dfe6ead193a404a6e34fda71e98188859f1e9c828a9778fff1b262
+  data.tar.gz: e5ce31cff8c62f5cab9ce6a59d33e90847bfbbe89e2d9445d8f51ce8540fe67c
 SHA512:
-  metadata.gz: 7222b463dd74c7ba154d363dabaf451979562831313583ac2e6fc034ddda595c13b3c4b1ae6772906842a92aa83842bb9a37c2c99f198c5a4985c82a3f61174c
-  data.tar.gz: 682b890f4c30d28d0786c6d3f7d03ac1d024fbec025119373346f9bcb87cad22391328b02238007ab9550cf6dd8ef07f565cc69628e26084fc2815a4b2d8e095
+  metadata.gz: cf3f73f8533cf2bd1145e3beffd12f602150eae3b4ad0031df24eaecac36bef6536d04e18a15b20cb2d6f529812a5cb63f2dfad28ed0638820a582f6e0ff37c9
+  data.tar.gz: da96da090f714b1d0811d475d091f637d4124931168039a2d0de2190b4022860e40a0c099819fb1d359c2ee055daba984d87a9748d9481e635fbe9673ea6eab6

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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.

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

@@ -90,7 +90,7 @@ module Legion
           def fetch_model_detail(model_name)
             raw = show_model(model_name)
             context_window = extract_context_window(raw)
-            { context_window: context_window }.compact
+            { 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)
@@ -249,7 +249,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 +258,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 +383,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 +398,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 +411,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
 
@@ -372,15 +464,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.9'
+        VERSION = '0.2.11'
       end
     end
   end

metadata

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