lex-llm-ollama 0.2.14 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bbec813c20e8b5c62b97209466439569cfcde42251acfe9e87f2bb0fce79e9d
-  data.tar.gz: 59822c6527476ec0000af57ec2a5884672d03065ca3212e0fb655faf809cc0da
+  metadata.gz: 7850eb1a4f0fcf50d9d0a86de7b9c2e60fa47154e1c6b330a492abeb00c25803
+  data.tar.gz: 24e040db015065dd7e508a995aa0f2b072910da41552029a1ff561993961331a
 SHA512:
-  metadata.gz: 6f41591f42a566ab7f3344e6d9963393db977dfea257b61c4a4aea798943804cc1db9f9525522cb690e5ab0448bc4b1451ee2ec3a67b615caccb049e84607bc4
-  data.tar.gz: effc50944c4583c1732ea4b23563c2f1ac00f660c0571e6c001403f3a140027303fe3bd77d2e0e64c61db39828a5230f9a35f30e7a1ab8663a3dd4e8b56bc185
+  metadata.gz: 762912cf8067d8b1c9019ea2d1d10261e234abac127ad1eeeecb5d2b7e41219c09f6294f68f022f0ad33b1f2eb95332db8b1ed3521eeef84aecfbeb11c3f186e
+  data.tar.gz: 9f99c4bc9f342d1061077d9dd8f663b35a0a9c962515cddbcf76d19a55fa734040ab8f4b7f7fd6767395d3dd9582913c6b2dbd3ac3010d10c787e932f218fd6a

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,19 @@
 # Changelog
 
+## 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.5.0'
 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
@@ -112,10 +116,11 @@ module Legion
             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)
 
-              offering_from_model(model_info)
+              offering_from_model(model_info, loaded: running_ids.include?(model_info.id.to_s))
             end
             log.debug { "ollama provider built offering_count=#{offerings.size} live=#{live}" }
             offerings
@@ -159,7 +164,14 @@ 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, loaded: false)
+            policy = resolve_capability_policy(model_info)
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :ollama,
               instance_id: config.respond_to?(:instance_id) ? config.instance_id : :default,
@@ -167,18 +179,64 @@ module Legion
               tier: offering_tier,
               model: model_info.id,
               usage_type: offering_usage_type(model_info),
-              capabilities: offering_capabilities(model_info),
+              capabilities: policy[:capabilities],
+              capability_sources: policy[: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_level_config,
+              instance_config: instance_level_config,
+              model_config: model_level_config(model_id)
+            )
           end
 
-          def offering_capabilities(model_info)
-            model_info.capabilities.map(&:to_s)
+          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 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
 
           def offering_limits(model_info)
@@ -357,16 +415,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 +438,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)
-            )
+          def legacy_tool_calls(canonical_tool_calls)
+            return nil if canonical_tool_calls.nil? || canonical_tool_calls.empty?
 
-            [
-              extraction.content,
-              Thinking.build(text: extraction.thinking, signature: extraction.signature)
-            ]
-          end
-
-          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.17'
       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.17
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.5.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: