lex-llm-ollama 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c00ff8929f8723127315d78b2141144a64319b2af41526098397717f4833568a
-  data.tar.gz: 2bc5494b6cdd8ec0f4268218e530719baeadd75126c71f70bdbbc96f4e4fc468
+  metadata.gz: a177e3c66491656118281eebec6069dd43e940b3a196988cd3d8584475d25204
+  data.tar.gz: 57b9c3122995c06dbfe08a3fffa43e7f77c793d9193b5786999322d8d32a2ee1
 SHA512:
-  metadata.gz: b3a2b92564e059f37584612350f1e67a1f260d224b3237feaa8ba3158d4cef7d741765930dbd6a3d34694fcb7d8b1ce50ec43da743874a558134fbe32a9ad454
-  data.tar.gz: 6f79d61f8fd32e268d1363c21a78209f41a78560d8f22f8a60cfe0d5c35f97a3987e0900fb111b99b5721fe23d94bc9842f4132f86a3fe64c2f828c10c38984f
+  metadata.gz: d4bcfbd0097b907bbee4bcf18de5e7942f0c288f79d09c9c4e54e853ca5f03db8ac1b419ae102575adeee5c8f3af90289527a148cdefd7b3c2a747ce90d83252
+  data.tar.gz: ed1527ef8e11f45410a8161078826acd7a2a20842a58ccd9e85d9956d947f68c49311ddc41f7f2ba751f53c46976f8540dddbf019ad2d5d650ac2d3e738d5091

data/.rubocop.yml

@@ -14,6 +14,8 @@ Metrics/BlockLength:
     - spec/**/*
 Metrics/MethodLength:
   Enabled: false
+Metrics/ModuleLength:
+  Max: 350
 Metrics/ParameterLists:
   Enabled: false
 Metrics/AbcSize:

data/CHANGELOG.md

@@ -1,8 +1,26 @@
 # Changelog
 
+## [0.3.7] - 2025-08-25
+
+### Fixed
+- **Thinking config contract** — reconcile to lex-llm 0.8.x `Canonical::Thinking::Config` (Data struct with `enabled`, `effort`, `budget`, `summary`, `metadata`). Removed the deleted `Canonical::Params#max_thinking_tokens` reference (`log_dropped_thinking_params` method and call site deleted — the member no longer exists). Removed the `Hash` branch in `enable_thinking?` — `request.thinking` is always a `Canonical::Thinking::Config` or nil. `apply_thinking_config` now emits `think: false` for a disabled Config (explicit off) and `think: true` for an enabled Config; omits the key entirely when no Config is present.
+
 ## [Unreleased]
 
+### Changed
+- **lex-llm 0.8.0 conformance** — legacy-to-canonical migration and the 0.8.0 contract cut across the gem:
+  - **Legacy type rip** — `provider.rb` no longer constructs or consumes the deleted `Llm::Message`/`Chunk`/`Thinking`/`ToolCall`/`Content::Raw`/`Embedding` types. `parse_completion_response` is the one response-parse boundary returning `Canonical::Response` (08 R2); `build_chunk` is the one chunk-parse boundary returning `Canonical::Chunk`; the `to_legacy_*` re-canonicalization bridges are deleted. Streaming runs the shared `StreamAccumulator` (10 U1) and honors the one streaming contract: yields `Canonical::Chunk`, ends in exactly one `done` chunk (or an `error` chunk before the raise), returns the accumulated `Canonical::Response`; a non-200 NDJSON body now raises the typed error through the shared streaming failure path instead of being silently skipped into an empty "successful" stream.
+  - **Renderer law (08 R1–R4)** — `render_payload` renders FROM canonical values with the 0.8.0 funnel signature (`params:` is `Canonical::Params | nil`, the `temperature:` kwarg is gone); the provider-spelled options keys (G18: `num_predict`, ...) are the translator's `options_for` edge mapping — the one params table in the gem. Tool arguments parse through the shared strict `Responses::ToolArguments.parse!` (10 U2): invalid JSON raises, the rescue-to-`{}` tolerance is deleted. Streaming tool-call deltas carry the accumulator fragment shape (`{ id:, name:, arguments: String, index: }`); Ollama's per-chunk complete-state re-send is handled by the accumulator's per-id replace semantics.
+  - **Discovery read path (07 C5)** — the provider's legacy `discover_offerings` live-discovery override and its `Routing::ModelOffering` production (`offering_from_model` and helpers) are deleted; the base read path serves the activated inventory offerings from `Registry.snapshot`. The SSOT discovery actor remains the sole publication path (`OfferingDraft` + `WeightReconciler` under the writer mutex). The embedding operation returns the 05 §3 documented artifact (`{ text:, model:, embedding:, usage: }`) in place of the deleted `Llm::Embedding` object.
+  - **Coordinator wiring rip** — the `Inventory::ScopedRefresher::LegacyCoordinatorAdapter` require and `Publisher` argument are removed from the discovery actor (the file is gone from lex-llm 0.8.0; the mixed-version projection window is over). The fleet worker runner passes `registry:` explicitly to `ProviderResponder.call` (fleet protocol v3: exact execution resolves the callable from the SSOT registry; the legacy `provider_class:`/`provider_instances:` arguments are gone).
+  - **Callable contract** — `OllamaCallable#chat`/`#stream_chat` take `messages` positionally, matching the 0.8.0 base Provider funnel and the fleet worker dispatch shape; `count_tokens`/`embed` keep their keyword `messages:`/`text:`. The callable-side `enforce_canonical_messages!` calls (the one shared helper at the exact-execution boundary) are kept.
+  - **Floor bump** — gemspec now requires `lex-llm >= 0.8.0`. `RULES.md` (the 0.8.0 architecture law) ships at the repo root, byte-for-byte.
+  - **Specs** — the provider spec rewrites the streaming/parser coverage against canonical types; the SSOT v3 conformance suite runs the kit's B1 (central enforcement) and B2 (canonical outputs) groups against the real callable boundary; the dispatch-boundary regression block now drives rejection through the funnel/callable (the base enforces centrally — the per-provider render-seam check is deleted with the legacy Chat-facade entry it existed for).
+
 ### Fixed
+- **Canonical dispatch boundary (2026-08-19 incident)** — provider input is now canonical-only at both dispatch seams: `OllamaCallable`'s fleet dispatch ops (`chat`, `stream_chat`, `count_tokens`) call the lex-llm 0.7.7 base `Provider#enforce_canonical_messages!` before delegating, and the provider's render seam (`render_payload` → `enforce_render_messages!`) accepts only `Canonical::Message` (pipeline dispatch) or provider-native `Legion::Extensions::Llm::Message` (Chat facade), raising a loud `ArgumentError` for anything else. The lenient provider-side re-canonicalization — the path that masked the 2026-08-19 hash bypass (25/25 failed openai dispatches) — is removed: zero Hash tolerance, no bridges, no adapters. The Ollama wire payload and client request formats are unchanged.
+- **lex-llm 0.7.7 floor** — the gemspec now requires `lex-llm >= 0.7.7` for `Provider#enforce_canonical_messages!` and the first-class canonical `cache_control` member; the bare registry `gem 'lex-llm'` line is replaced by a test-group path dependency on the adjacent `../lex-llm` checkout so the boundary work resolves against 0.7.7 during development.
+- **Dispatch-boundary specs** — the SSOT v3 conformance suite gains a dispatch-boundary regression block: canonical input (including the `cache_control` member) renders through the production render seam without leaking the transport-only key onto the wire, plain-Hash input raises at both the fleet callable and the render seam, and provider-native `Message` input continues to render through the seam; the `RecordingOllamaProvider` stand-in delegates `enforce_canonical_messages!` to the real base implementation.
 - **Complete discovery change detection** — ordinary discovery now compares the complete stable `OfferingDraft#to_h` contract as an order-independent, duplicate-count-preserving multiset. Only evidence `observed_at` telemetry is excluded; quota domains, metadata, publication source, scalar evidence authority, and every other draft field trigger one atomic replacement when changed.
 - **Startup claim atomicity** — initial model discovery and write-time weight validation now complete before Ollama constructs a callable, coordinator, or Registry claim, so malformed settings cannot leave an orphan `:initializing` publication status or token; the next corrected discovery pass claims and activates the instance exactly once without a restart or operator repair.
 - **SSOT v3 write-time weights** — Ollama drafts now publish the validated four-axis weight pair from live settings, and the existing discovery cadence atomically reconciles weight-only changes, initialization/activation races, sequence/cache updates, removals, and dormant configured-weight logging through lex-llm 0.7.6. No Settings callback, reload, reset, migration, restart, or operator action is introduced.

data/Gemfile

@@ -2,10 +2,15 @@
 
 source 'https://rubygems.org'
 
-gem 'lex-llm'
-
 gemspec
 
+# Local-tree resolution: use the adjacent lex-llm checkout when present so the
+# 0.8.0 conformance work resolves against the unreleased 0.8.0 contract cut.
+group :test do
+  lex_llm_path = File.expand_path('../lex-llm', __dir__)
+  gem 'lex-llm', path: lex_llm_path if Dir.exist?(lex_llm_path)
+end
+
 group :development do
   gem 'bundler', '>= 2.0'
   gem 'rake', '>= 13.0'

data/RULES.md

@@ -0,0 +1,97 @@
+RULES.md — Legion LLM Architecture Law
+These rules apply to every task, file, repository, agent, model, session, test, refactor, migration, incident, and release.
+The requested task defines what may change. These rules define how the system ALWAYS works.
+Every rule remains active 100% of the time. If requested work conflicts with these rules, stop and surface the conflict before changing code.
+These are architecture laws. Scope, compatibility, urgency, convenience, tests, existing behavior, and model judgment do not change them.
+1. Canonical is the only internal language.
+Every client translates client wire -> Canonical before shared execution.
+Shared execution carries Canonical through context, tools, routing, direct dispatch, fleet dispatch, and response handling.
+Every provider translates Canonical -> provider wire at the provider boundary, then provider wire -> Canonical before returning to shared execution.
+Every internal boundary validates the Canonical type it is defined to receive and raises immediately when that contract is violated.
+Client Wire -> Client Translator -> Canonical -> Shared Execution -> Canonical -> Provider Translator -> Provider Wire.
+2. Serialization preserves Canonical.
+Transport may serialize Canonical state. The receiving transport boundary ALWAYS rehydrates the exact Canonical type before execution continues.
+Fleet follows Canonical -> serialize -> wire -> deserialize -> rehydrate Canonical -> Canonical.
+Serialization changes encoding only. Ownership, identity, model, operation, capability, selection, and meaning remain exactly the same.
+After rehydration, shared execution continues only with Canonical objects.
+3. Every authoritative fact has exactly one owner.
+The owner creates the fact once. Every downstream layer carries, projects, serializes, rehydrates, verifies, or executes that exact fact.
+A downstream layer receiving missing or contradictory authoritative state raises and returns the defect to the owning layer.
+Authority ALWAYS moves forward by preservation.
+Authority is created once and is never recreated downstream.
+4. Requirements describe the request. Inventory describes reality. Router chooses. Dispatch executes.
+Canonical request construction owns request semantics. RequestRequirements expresses operation, capabilities, modality, context, output, tools, and explicit pins.
+Providers publish exact executable facts into Inventory. Inventory owns canonical instance, offering, lane, capability, context, quota, health, and published weight state.
+Router.next_lane consumes Requirements plus one immutable Inventory snapshot and produces one authoritative Selection.
+Dispatch executes that Selection exactly. Once Selection exists, routing is finished.
+5. Inventory facts are immutable executable facts.
+Providers publish exact instances and complete offering snapshots through the Inventory publication contract.
+Identity, capability evidence, context evidence, quota domains, availability, and write-time weights are consumed from published Inventory state.
+A changed fact becomes authoritative only through the owning publication or reconciliation path and a new Inventory snapshot.
+Routing reads Inventory. Dispatch verifies and executes Inventory-backed Selection.
+6. Identity, capabilities, weights, and context policy retain exact ownership.
+Inventory::Identity owns instance, offering, and lane identity; canonical instance identity is provider family plus the operator/configured instance name; physical endpoint data remains secondary.
+Providers publish capability evidence. Requirements state required capabilities. Candidate evaluation compares the two and determines capability eligibility.
+The weight owner computes lane weight at publication time; Inventory stores it; ranking consumes that stored weight; a stored zero disables the lane.
+Preferred-context binning orders eligible candidates into preference bands and preserves eligibility. Capability, health, binning, and weight ALWAYS retain distinct meanings.
+7. Routing chooses exactly once.
+Router.next_lane is the sole routing authority.
+Candidate evaluation determines eligibility from Requirements and Inventory. Ranking orders eligible candidates from published routing facts.
+Selection freezes the exact provider, instance, offering, lane, model, operation, and routing identity required for execution.
+Every downstream component consumes the Selection it receives.
+Selection is preserved, not reconstructed.
+8. Exact execution stays exact through every boundary.
+Direct dispatch executes the exact Selection-derived binding it receives.
+Fleet dispatch serializes and signs that exact binding; fleet validation verifies it; fleet rehydration restores it; worker resolution verifies it against authoritative Inventory.
+The selected provider, instance, offering, lane, model, and operation remain identical through projection, signing, transport, validation, rehydration, resolution, and callable invocation.
+A mismatch raises before provider execution.
+An exact execution request ALWAYS remains exact execution.
+9. Health and errors preserve one authoritative meaning.
+Inventory owns exact-instance availability. An authoritative instance-unavailable result removes that exact instance; readiness probing owns recovery; successful readiness republish re-admits it.
+Overload, timeout, rate limit, model-not-ready, and transient provider failures remain request-local according to ProviderOutcome semantics.
+The first layer that can authoritatively classify an error performs that classification once. Every downstream layer preserves it.
+Programming errors remain programming errors. Contract violations remain contract violations. Routing exhaustion remains the defined typed Rejection.
+10. Compatibility exists only at explicit edges.
+Supported legacy clients and protocols are translated into the current Canonical and SSOT architecture at explicit compatibility boundaries.
+Shared execution remains Canonical. Routing remains SSOT-driven. Exact execution remains exact.
+Compatibility code adapts an external contract to the current internal architecture.
+The current internal architecture ALWAYS has one representation, one routing authority, one identity system, and one execution truth.
+11. Fix every defect at its owner.
+Trace the incorrect value to the layer that owns it, then fix that owner.
+Fix client wire in the client translator; Canonical shape in Canonical construction; Requirements in Requirements construction; provider facts in publication; identity in Inventory identity; weights in publication/reconciliation.
+Fix eligibility in candidate evaluation; ordering in ranking; choice in Router.next_lane; execution preservation in dispatch; provider wire in the provider translator.
+The layer where a defect becomes visible is evidence. The owning layer is where the correction belongs.
+12. A discovered issue remains in its owning domain.
+Complete the requested task inside its stated scope.
+When investigation exposes a separate defect owned by another architectural domain, record and surface it as separate work unless the requested task is explicitly expanded.
+Routing work consumes existing Canonical Requirements and Inventory facts. Canonical work changes Canonical contracts. Provider work changes publication or translation. Transport work changes transport.
+Nearby code never changes ownership. “While we are here” never changes architecture.
+13. N x N ALWAYS converges through Canonical.
+Equivalent client semantics produce equivalent Canonical state before shared execution. Every provider consumes the same Canonical semantics for the same request.
+When two paths disagree, capture the state at every involved boundary and locate the FIRST point where Canonical meaning diverges.
+Fix that first divergent boundary, then run the exact failing path again.
+Client behavior is proven at client-wire <-> Canonical. Provider behavior is proven at Canonical <-> provider-wire. Shared execution is proven with Canonical throughout.
+14. Debug from captured authoritative state.
+Capture the actual input at the failing boundary before reasoning from symptoms.
+For translation or transport defects, capture Canonical immediately before and after every involved boundary.
+For routing or dispatch defects, capture Requirements, relevant Inventory facts, Selection, execution binding, and ProviderOutcome.
+Compare each captured value to the contract owned by that layer. Find the first divergence. Fix its owner. Re-run the exact path.
+Then inspect sibling implementations for the same defect class.
+15. Tests prove the real boundary and the invariant.
+A boundary test exercises the real boundary it claims to protect.
+Fleet tests exercise real serialization, deserialization, Canonical rehydration, signing, validation, exact resolution, and callable dispatch.
+Provider tests exercise the real callable boundary and provider translator. Routing tests exercise real Requirements, Inventory records, candidate evaluation, ranking, and Selection.
+Regression tests prove the violated invariant, not only the observed symptom.
+A green suite is release evidence only when the tested path traverses the real architecture.
+16. Shared contracts are consumed directly.
+Shared Canonical types own execution representation. Shared Inventory types own inventory state. Shared Routing types own routing state.
+Shared taxonomy owns canonical mappings. Shared ProviderOutcome owns provider-neutral outcomes. Shared fleet protocol owns exact execution claims.
+Every repository consumes these shared owners directly.
+A defect in one shared boundary triggers an audit of every sibling implementation of that boundary. Fix the shared owner centrally whenever the defect belongs to a shared contract.
+17. Architecture is the release gate.
+Every change preserves every rule in this file.
+Tests, compatibility, historical behavior, migration phase, patch urgency, nearby code, task wording, and model judgment are evaluated UNDER these rules.
+A contradiction between existing behavior and these rules is surfaced as an architecture conflict and resolved at the owning boundary before release.
+Limited scope means do less. Limited scope NEVER means fewer rules apply.
+These rules apply 100% of the time.
+These are the law.

data/lex-llm-ollama.gemspec

@@ -27,6 +27,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.4.2'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  # 0.7.6 adds write-time WeightSchema records and the atomic writer reconciler.
-  spec.add_dependency 'lex-llm', '>= 0.7.6'
+  # 0.8.0 is the contract cut this gem conforms to: canonical-only provider
+  # funnel (central enforce_canonical_messages!), Canonical::Response/Chunk
+  # output, Registry-snapshot discovery read path, fleet protocol v3, and the
+  # legacy Llm::* type rip.
+  spec.add_dependency 'lex-llm', '>= 0.8.0'
 end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/discovery/actor'
+
+# The base discovery actor only exists inside the daemon (it inherits the
+# LegionIO time-based Every actor). In a standalone load, define nothing.
+return unless defined?(Legion::Extensions::Llm::Discovery::Actor)
+
+module Legion
+  module Extensions
+    module Llm
+      module Ollama
+        module Actor
+          # Ollama discovery actor: an EMPTY subclass of the shared base. The
+          # timer, dispatch, and runner-resolution convention are inherited —
+          # this class redefines nothing. The Ollama-specific work lives in
+          # Ollama::Runners::Discovery, resolved by the base from this namespace.
+          class Discovery < Legion::Extensions::Llm::Discovery::Actor; end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ollama/helpers/callable.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require 'legion/extensions/llm/routing/provider_outcome'
+require 'legion/extensions/llm/ollama/provider'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ollama
+        module Helpers
+          # Callable wrapper for an Ollama provider instance. Implements the
+          # fleet dispatch ops (chat/stream_chat/embed/count_tokens) by delegating
+          # to a per-instance Ollama::Provider, plus the disconnect and
+          # normalize_dispatch_error contracts required by Inventory::CallableHandle
+          # and Routing::ProviderOutcome. Dispatch errors propagate untouched so
+          # normalize_dispatch_error can classify them.
+          class Callable
+            # Keys the base Provider exposes as named kwargs for the completion
+            # operations. Anything else the fleet passes (sampling scalars,
+            # `temperature` — a Canonical::Params member, 05 O4) is folded into
+            # Canonical::Params at the dispatch boundary.
+            COMPLETION_NAMED_KEYS = %i[tools schema thinking tool_prefs headers].freeze
+            EMBED_NAMED_KEYS = %i[dimensions headers].freeze
+
+            def initialize(instance_cfg:, logger:, provider: nil)
+              @instance_cfg = instance_cfg
+              @logger = logger
+              @provider = provider
+              @disconnected = false
+            end
+
+            def disconnected? = @disconnected
+
+            def disconnect
+              @disconnected = true
+              @provider&.disconnect
+              @logger.debug { '[ollama][callable] disconnected' }
+            end
+
+            # Fleet and SelectionDispatch pass model as a RAW STRING (the
+            # offering's model id). Ollama's render path is string-tolerant
+            # (model.respond_to?(:id) ? model.id : model) for chat and embed,
+            # embed places the model verbatim in the 05 §3 embedding artifact,
+            # and count_tokens ignores it — so the model passes through
+            # UNWRAPPED on every op.
+            # 0.8.0 callable contract: chat/stream_chat take the rehydrated
+            # message array positionally (WorkerExecution dispatch shape);
+            # count_tokens takes the messages: kwarg (worker_execution.rb);
+            # the Selection-derived model is a bare String.
+            def chat(messages, model:, **rest)
+              # Canonical boundary (N x N law): pipeline dispatch delivers
+              # Canonical::Message objects only. Hash shapes are the bypass
+              # class — reject loudly, never coerce.
+              provider.enforce_canonical_messages!(messages)
+              named, params = split_fleet_kwargs(rest, COMPLETION_NAMED_KEYS)
+              provider.chat(messages, model: model, params: canonical_params(params), **named)
+            end
+
+            def stream_chat(messages, model:, **rest, &)
+              provider.enforce_canonical_messages!(messages)
+              named, params = split_fleet_kwargs(rest, COMPLETION_NAMED_KEYS)
+              provider.stream_chat(messages, model: model, params: canonical_params(params), **named, &)
+            end
+
+            def embed(text:, model:, **rest)
+              named, params = split_fleet_kwargs(rest, EMBED_NAMED_KEYS)
+              provider.embed(text: text, model: model, params: params, **named)
+            end
+
+            def count_tokens(messages:, model:, **rest)
+              provider.enforce_canonical_messages!(messages)
+              _named, params = split_fleet_kwargs(rest, [])
+              provider.count_tokens(messages: messages, model: model, params: params)
+            end
+
+            def normalize_dispatch_error(error:)
+              Legion::Extensions::Llm::Routing::ProviderOutcome.new(
+                kind: classify_dispatch_error(error: error),
+                reason: dispatch_reason(error)
+              )
+            end
+
+            private
+
+            def canonical_params(params)
+              Legion::Extensions::Llm::Canonical::Params.from_hash(params)
+            end
+
+            def split_fleet_kwargs(rest, named_keys)
+              named = rest.slice(*named_keys)
+              extra = rest.reject { |key, _| named.key?(key) }
+              params = (extra.delete(:params) || {}).to_h.merge(extra)
+              [named, params]
+            end
+
+            def classify_dispatch_error(error:)
+              return :model_not_ready if model_not_ready?(error: error)
+
+              base_kind = base_classifier.normalize_dispatch_error(error: error).kind
+              return base_kind unless base_kind == :provider_error && faraday_status_error?(error)
+
+              status_kind(dispatch_status(error))
+            end
+
+            def base_classifier
+              @base_classifier ||= Legion::Extensions::Llm::Ollama::Provider.new({})
+            end
+
+            def faraday_status_error?(error)
+              error.is_a?(Faraday::ClientError) || error.is_a?(Faraday::ServerError)
+            end
+
+            # §8 health firewall: Ollama emits no explicit flat
+            # instance-unavailable dispatch signal (a dead server simply drops
+            # the connection — that is the :connection_failure down-signal, which
+            # the readiness probe then turns into an availability transition).
+            # Status code alone (503/5xx) never maps to :instance_unavailable.
+            def status_kind(status)
+              case status
+              when 401 then :authentication
+              when 403 then :authorization
+              when 404 then :model_missing
+              when 429 then :rate_limited
+              when 503, 529 then :overloaded
+              when 400...500 then :invalid_request
+              else :provider_error
+              end
+            end
+
+            def model_not_ready?(error:)
+              status = dispatch_status(error)
+              return false unless status.is_a?(::Integer) && status >= 500
+
+              response_body_string(error).to_s.match?(/model.{0,10}(not\s+(loaded|ready)|loading)/i)
+            end
+
+            def response_body_string(error)
+              response = error.respond_to?(:response) ? error.response : nil
+              return nil if response.nil?
+
+              body = response.respond_to?(:body) ? response.body : (response[:body] if response.respond_to?(:[]))
+              return body if body.is_a?(String)
+
+              body && ::JSON.generate(body)
+            end
+
+            def dispatch_status(error)
+              return error.response_status if error.respond_to?(:response_status) && error.response_status
+
+              response = error.respond_to?(:response) ? error.response : nil
+              return response.status if response.respond_to?(:status) && response.status
+              return response[:status] if response.respond_to?(:[]) && response[:status]
+
+              nil
+            end
+
+            def dispatch_reason(error)
+              reason = error.message.to_s[0, 512]
+              reason.empty? ? 'unknown dispatch error' : reason
+            end
+
+            def provider
+              @provider ||= build_provider
+            end
+
+            def build_provider
+              Legion::Extensions::Llm::Ollama::Provider.new(provider_config)
+            end
+
+            def provider_config
+              cfg = @instance_cfg.to_h.transform_keys(&:to_sym)
+              base_url = cfg[:base_url] || cfg[:endpoint]
+              return {} unless base_url.is_a?(String) && !base_url.strip.empty?
+
+              { base_url: base_url }
+            end
+          end
+        end
+      end
+    end
+  end
+end