lex-llm-ollama 0.2.13 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8edb9398901726a46e399fd9a7ab11a9686c3cf76bd6cd7efc2cc48c89005230
-  data.tar.gz: 89e29c003fac6d296e26f9214cde4f93c499cb5f8ccaa065d8270a587f6bb9f5
+  metadata.gz: 7850eb1a4f0fcf50d9d0a86de7b9c2e60fa47154e1c6b330a492abeb00c25803
+  data.tar.gz: 24e040db015065dd7e508a995aa0f2b072910da41552029a1ff561993961331a
 SHA512:
-  metadata.gz: f9a7f5bb4fd18596bec2b301fd92ed49cf4c2fdb77d592d85ef54c834bef8f5a4770c3c7b773c8a50a84737595309439826e6a4c110cf62497c8a61242251edb
-  data.tar.gz: 927d0afc66e6ef69fbf3754defdbb03e4ff6891d71046c4bf722d88cf5c56ec32b573fa4066ce9421c2a51e1b596378f9f8cd906df8f0ea37da9546bd1b610f2
+  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,24 @@
 # 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)
+- Updated README with comprehensive extension index covering architecture, classes, configuration, and usage
+
 ## 0.2.13 - 2026-06-02
 
 - **Scope discovery refresh to Ollama only** — `DiscoveryRefresh#manual` now calls `Discovery.refresh_discovered_models!(provider: :ollama)` instead of `Discovery.run`, which previously triggered model discovery for all registered providers (anthropic, bedrock, etc.) and caused cross-provider coupling

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/README.md

@@ -2,38 +2,134 @@
 
 LegionIO LLM provider extension for [Ollama](https://ollama.ai).
 
-This gem lives under `Legion::Extensions::Llm::Ollama` and depends on `lex-llm >= 0.4.3` for shared provider-neutral routing, response normalization, fleet envelopes, responder execution, transport, and registry primitives. It does not carry a runtime `legion-llm` dependency; `legion-llm` owns higher-level routing and can discover this provider through normal extension loading.
+This gem lives under `Legion::Extensions::Llm::Ollama` and depends on `lex-llm >= 0.4.3` for shared provider-neutral routing, response normalization, fleet envelopes, responder execution, transport, and registry primitives. It does not carry a runtime `legion-llm` dependency; `legion-llm` owns higher-level routing and discovers this provider through normal extension loading.
 
 Load it with `require 'legion/extensions/llm/ollama'`.
 
 ## What It Provides
 
-- Ollama-native chat requests through `POST /api/chat`
-- Streaming chat support
-- Model discovery through `GET /api/tags` with automatic embedding capability inference
-- Running model inspection through `GET /api/ps`
-- Model details through `POST /api/show`
-- Model download helper through `POST /api/pull`
-- Embeddings through `POST /api/embed`
-- Best-effort `llm.registry` availability events via the shared `Legion::Extensions::Llm::RegistryPublisher`
-- Local socket discovery plus configured instance discovery through the shared `lex-llm` credential sources
-- Provider-owned fleet response handling through `Legion::Extensions::Llm::Fleet::ProviderResponder`
-- Full `Legion::Logging::Helper` integration with structured `handle_exception` in every rescue block
+| Feature | Endpoint | Provider Method |
+|---------|----------|----------------|
+| Chat completion | `POST /api/chat` | Inherited from `Lex-llm` base provider |
+| Streaming chat | `POST /api/chat` | `stream_response` |
+| List models | `GET /api/tags` | `list_models` |
+| Running models | `GET /api/ps` | `list_running_models` |
+| Model details | `POST /api/show` | `show_model`, `fetch_model_detail` |
+| Pull models | `POST /api/pull` | `pull_model` |
+| Embeddings | `POST /api/embed` | Inherited from `Lex-llm` base provider |
+| Readiness check | `GET /api/version` | `readiness(live: false)` |
+
+All responses pass through the shared `Lex-llm` normalization layer: `Message`, `Chunk`, `Embedding`, and `Model::Info`.
+
+## File Index
+
+```
+lib/
+  legion/extensions/llm/ollama.rb              # Extension entry point, instance discovery, default settings
+  legion/extensions/llm/ollama/provider.rb     # Provider — chat, stream, embed, models, offerings
+  legion/extensions/llm/ollama/version.rb      # VERSION constant
+  legion/extensions/llm/ollama/actors/
+    discovery_refresh.rb                       # Periodic model discovery actor (Every, 30min default)
+    fleet_worker.rb                            # Fleet request subscription actor (Subscription)
+  legion/extensions/llm/ollama/runners/
+    fleet_worker.rb                            # Fleet request execution runner (delegates to lex-llm)
+```
 
 ## Architecture
 
 ```
 Legion::Extensions::Llm::Ollama
-├── Provider                   # Ollama provider (chat, stream, embed, models, readiness)
-├── Actor::FleetWorker         # Optional provider-owned fleet subscription actor
-├── Runners::FleetWorker       # Delegates fleet execution to lex-llm
-└── (shared from lex-llm)
-    ├── Fleet::ProviderResponder
-    ├── RegistryPublisher
-    ├── RegistryEventBuilder
-    └── Transport/
+├── Provider                          # Ollama provider implementation
+│   ├── Capabilities                  # Capability predicates (chat, streaming, vision, functions, embeddings)
+│   ├── #render_payload               # Build Ollama chat payload from messages, tools, schema
+│   ├── #stream_response              # NDJSON streaming via Faraday on_data
+│   ├── #discover_offerings           # Build ModelOffering array from live/cached models
+│   ├── #fetch_model_detail           # Call /api/show, extract context_window + capabilities
+│   ├── #render_embedding_payload     # Build Ollama embedding payload
+│   └── (inherited from lex-llm)      # Chat, embedding, connection, registry helpers
+├── Actor::DiscoveryRefresh           # Every actor; refreshes model list, repopulates auto rules
+├── Actor::FleetWorker                # Subscription actor; gates on respond_to_requests
+└── Runners::FleetWorker              # Module function; delegates to ProviderResponder.call
+
+Shared from lex-llm:
+├── Fleet::ProviderResponder          # Fleet request execution harness
+├── RegistryPublisher                 # Publishes readiness + model events to llm.registry
+├── RegistryEventBuilder              # Builds registry event payloads
+├── AutoRegistration                  # Self-registers discovered instances
+└── CredentialSources                 # Socket probing + setting lookup for instance discovery
 ```
 
+## Key Classes
+
+### `Legion::Extensions::Llm::Ollama` (module)
+
+- **`default_settings`** — Returns the full settings schema via `Lex-llm.provider_settings`.
+- **`provider_class`** — Returns `Provider`.
+- **`discover_instances`** — Probes `127.0.0.1:11434` socket + reads configured instances from settings.
+- **`normalize_instance_config(config)`** — Normalizes `endpoint`/`api_base`/`ollama_api_base` aliases to `base_url`.
+- **`registry_publisher`** — Lazily instantiated `RegistryPublisher` for the `:ollama` family.
+
+### `Provider`
+
+Extends `Legion::Extensions::Llm::Provider`. Implements the Ollama-specific contract:
+
+| Method | Purpose |
+|--------|---------|
+| `api_base` | Resolves base URL from `resolve_base_url`, settings, or default `127.0.0.1:11434` |
+| `completion_url` | `/api/chat` |
+| `stream_url` | `/api/chat` |
+| `models_url` | `/api/tags` |
+| `running_models_url` | `/api/ps` |
+| `show_model_url` | `/api/show` |
+| `embedding_url` | `/api/embed` |
+| `pull_url` | `/api/pull` |
+| `version_url` | `/api/version` |
+| `list_running_models` | GET `/api/ps`, returns array of running model hashes |
+| `readiness(live:)` | Checks Ollama version endpoint; publishes readiness event when `live: true` |
+| `list_models` | GET `/api/tags`, parses and publishes model events via registry |
+| `show_model(model)` | POST `/api/show`, returns raw model detail hash |
+| `fetch_model_detail(model)` | Wraps `show_model`; extracts `context_window` and `capabilities` |
+| `pull_model(model, stream:)` | POST `/api/pull` to download a model |
+| `discover_offerings(live:)` | Builds `ModelOffering` array from live or cached models |
+| `render_payload(...)` | Converts Legion messages/tools to Ollama NDJSON format |
+| `stream_response(conn, payload)` | Posts with Faraday `on_data` handler for NDJSON streaming |
+| `parse_completion_response(resp)` | Normalizes Ollama chat response to `Legion::Extensions::Llm::Message` |
+| `build_chunk(data)` | Normalizes a stream NDJSON line to `Legion::Extensions::Llm::Chunk` |
+| `render_embedding_payload(text, model:, dimensions:)` | Builds embedding request body |
+| `parse_embedding_response(resp, ...)` | Normalizes embedding response to `Legion::Extensions::Llm::Embedding` |
+
+### `Capabilities` (module inside Provider)
+
+Module functions providing capability predicates used during offering construction:
+
+| Method | Always Returns |
+|--------|---------------|
+| `chat?(model)` | `true` |
+| `streaming?(model)` | `true` |
+| `vision?(model)` | `true` |
+| `functions?(model)` | `true` |
+| `embeddings?(model)` | `true` |
+
+### `CONTEXT_WINDOWS` (constant)
+
+Static fallback map keyed by model name prefix (e.g., `'qwen3' => 128_000`). Used when `/api/show` is unavailable to infer context window. Covers qwen, llama, gemma, mistral, deepseek, phi, command-r, codellama, and embedding families.
+
+### `Actor::DiscoveryRefresh`
+
+An `Every` actor that runs every 30 minutes (configurable via `settings[:extensions][:llm][:ollama][:discovery_interval]`). On each tick:
+
+1. Calls `Legion::LLM::Discovery.refresh_discovered_models!(provider: :ollama)`
+2. Repopulates auto routing rules if `Legion::LLM::Router` is available
+3. Invalidates the offerings cache if `Legion::LLM::Inventory` is available
+
+### `Actor::FleetWorker`
+
+A `Subscription` actor that starts only when at least one instance has `fleet.respond_to_requests: true`. Routes messages to the fleet worker runner.
+
+### `Runners::FleetWorker`
+
+A module with `handle_fleet_request(payload, delivery:, properties:)`. Delegates to `Legion::Extensions::Llm::Fleet::ProviderResponder.call` with the Ollama provider family, provider class, and instance discovery lambda.
+
 ## Defaults
 
 ```ruby
@@ -65,21 +161,24 @@ Legion::Extensions::Llm::Ollama.default_settings
 
 ## Configuration
 
-`discover_instances` returns a local `http://127.0.0.1:11434` instance when the Ollama socket is reachable. Additional instances can be supplied under the shared LLM extension configuration and may use `base_url`, `endpoint`, `api_base`, or `ollama_api_base`; the extension normalizes those aliases to `base_url`.
+### Instance Discovery
+
+`discover_instances` auto-detects a local instance when the socket at `127.0.0.1:11434` is reachable. Additional instances can be defined in settings using any of the recognized endpoint aliases (`base_url`, `endpoint`, `api_base`, `ollama_api_base`); the extension normalizes all to `base_url`.
 
 ```yaml
 extensions:
   llm:
     ollama:
+      discovery_interval: 1800          # DiscoveryRefresh actor interval (seconds)
       instances:
         lab:
           base_url: http://ollama-lab:11434
           default_model: qwen3.5:latest
 ```
 
-## Fleet Responder
+### Fleet Responder
 
-Provider instances can opt in to consuming Legion LLM fleet requests. The provider-owned fleet actor only starts when at least one discovered instance enables `respond_to_requests`, and the runner delegates execution to the shared `lex-llm` responder helper.
+Provider instances can opt in to consuming Legion LLM fleet requests. The fleet actor only starts when at least one instance enables `respond_to_requests`, and the runner delegates execution to the shared `lex-llm` responder helper.
 
 ```yaml
 extensions:
@@ -96,14 +195,76 @@ extensions:
               - embed
 ```
 
+## Ollama API Surface
+
+| Legion Method | Ollama Route | HTTP Verb |
+|---------------|-------------|-----------|
+| Chat | `/api/chat` | POST |
+| Stream chat | `/api/chat` | POST |
+| List models | `/api/tags` | GET |
+| Running models | `/api/ps` | GET |
+| Model details | `/api/show` | POST |
+| Pull model | `/api/pull` | POST |
+| Embeddings | `/api/embed` | POST |
+| Readiness | `/api/version` | GET |
+
+## Error Handling
+
+Every rescue block uses `handle_exception` from `Legion::Logging::Helper` with explicit `level`, `handled:`, and `operation:` parameters. Connection failures during `discover_offerings` produce a warn-level log and return an empty array (never raise).
+
+## Usage
+
+```ruby
+require 'legion/extensions/llm/ollama'
+
+# Access the module
+Legion::Extensions::Llm::Ollama.discover_instances
+Legion::Extensions::Llm::Ollama.default_settings
+
+# Create a provider instance (usually done by lex-llm routing)
+provider = Legion::Extensions::Llm::Ollama::Provider.new(config:)
+
+# Discover offerings
+provider.discover_offerings(live: true)
+
+# Chat
+result = provider.chat(messages: [...], model: 'llama3', temperature: 0.7)
+
+# Stream chat
+provider.stream_chat(messages: [...], model: 'llama3') do |chunk|
+  print chunk.content
+end
+
+# Embeddings
+embeddings = provider.embed(text: "Hello world", model: 'nomic-embed-text')
+```
+
+## Dependencies
+
+| Gem | Minimum Version | Purpose |
+|-----|----------------|---------|
+| `lex-llm` | `>= 0.4.3` | Base provider contract, routing, fleet responder, registry, credential sources |
+| `legion-transport` | `>= 1.4.14` | Faraday connection management |
+| `legion-json` | — | JSON serialization (`Legion::JSON`) |
+| `legion-logging` | — | Structured logging (`Legion::Logging::Helper`) |
+| `legion-settings` | — | Configuration access |
+| `legion-extensions` | — | Extension framework (`Core`, `Actors::Every`, `Actors::Subscription`) |
+
 ## Development
 
 ```bash
+cd /Users/matt.iverson@optum.com/rubymine/legion/extensions-ai/lex-llm-ollama
 bundle install
-bundle exec rspec --format json --out tmp/rspec_results.json --format progress --out tmp/rspec_progress.txt
+
+# Run specs
+bundle exec rspec
+
+# Lint (auto-correct)
 bundle exec rubocop -A
 ```
 
+Spec count: 52 examples across 7 spec files.
+
 ## License
 
 MIT

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.13'
+        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.13
+  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: