lex-ollama 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7477574f919b18b85c79afba3a1f65c8540d9eff9ca02b9e0c807b3740fed452
-  data.tar.gz: a5c69878c8518caf02c2e238c94243fd49c320f20bfaede00252bfdc87be5cbb
+  metadata.gz: 8657f3e11e11fcd2ee34e12317bf7698bcfea1e907006c76f9a07326996c7a69
+  data.tar.gz: d1c1bbb05dc6a3a0071b4474a45a074b0d4929cd4b48b7488b5aa10539a9a6ee
 SHA512:
-  metadata.gz: 31566bf77244dd3cfc097531a3af1da186e8d0e7e0ec675be0b7471f8b7654649fa666d4c3d2f6bb34c46d73d29aa72a64dfa07f7beb35ae01d23c8f2bc6c797
-  data.tar.gz: f900e723d2db75dbdb266fcf33d01be56d7614b992be9e0b6d29345a85012be0d226ff9a2f42cb2d5a9f932cb1e641e6ecbfc033ccd3c6c98bbe4d2a7207ad13
+  metadata.gz: e2a8622a2914cdfbc04b365d1ca7a9e8d35b4daa656931fd23a6e010b25b5a8ed6699246bffdbe0bfe064757ad26cad8f3664fe8c1dd2d1c606220dc932af45f
+  data.tar.gz: ea975e9ac1c89621d41c274b6040bb92760672f9d4a2db223ea6c08371f7ed8e8a2dc810417b9b5b2beb9ce30fccb64544f24c11ae815422e5b99f5a43a48517

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.3.2] - 2026-04-08
+
+### Changed
+- `Transport::Exchanges::LlmRequest` now inherits `Legion::LLM::Fleet::Exchange` instead of declaring exchange properties independently — prevents silent divergence if the canonical exchange definition changes
+- `Transport::Queues::ModelRequest` switched from durable quorum queue to classic auto-delete with `x-max-priority: 10` — enables `basic.return` feedback when all workers disconnect; added `dlx_enabled: false` to prevent DLX provisioning on ephemeral queues
+- `Transport::Messages::LlmResponse` now inherits `Legion::LLM::Fleet::Response` instead of `Legion::Transport::Message` — gains wire protocol compliance (`type: 'llm.fleet.response'`, `message_context` propagation, default-exchange publishing, `resp_` prefixed message_id); overrides `app_id` to `'lex-ollama'`
+- `Runners::Fleet#handle_request` now accepts and propagates `message_context` verbatim from request to response; rejects `stream: true` requests with `unsupported_streaming` error; builds full wire protocol response envelope (routing, tokens, timestamps, audit, cost, stop)
+- `Runners::Fleet#publish_reply` switched from positional to keyword arguments; uses `fleet_correlation_id` instead of `correlation_id` to avoid collision with Legion task tracking
+- `Runners::Fleet#dispatch` now resolves Ollama host from `Legion::Settings` instead of using hardcoded default
+- `Actor::ModelWorker` now sets `prefetch(1)` for fair consumer dispatch; reads `consumer_priority` from `legion.ollama.fleet.consumer_priority` settings; passes `x-priority` in `subscribe_options`; injects `message_context: {}` default in `process_message`
+
+### Added
+- `Runners::Fleet#publish_error` — publishes `Legion::LLM::Fleet::Error` to caller's reply_to queue on validation failures (e.g., unsupported streaming)
+- `Runners::Fleet#build_response_body` — constructs wire protocol response body with routing, tokens, timestamps, audit, cost, and stop blocks
+
+## [0.3.1] - 2026-04-08
+
+### Added
+- `Runners::Fleet` — module-function dispatcher for inbound AMQP LLM request messages; routes by `request_type` to `Client#embed`, `Client#generate`, or `Client#chat`
+- `Transport::Exchanges::LlmRequest` — durable topic exchange `llm.request` for fleet routing
+- `Transport::Queues::ModelRequest` — parametric durable quorum queue per `(type, model)` pair; sanitises colons in model names to dots
+- `Transport::Messages::LlmResponse` — reply message published back to `reply_to` queue after inference
+- `Actor::ModelWorker` — subscription actor; one instance per configured `(type, model)` subscription; enriches inbound messages with `request_type` and `model`, bypasses Legion::Runner task DB (`use_runner? false`)
+- Fleet queue subscription system: when `Legion::Extensions::Core` is present, subscribes to model-scoped queues on `llm.request` topic exchange using routing key `llm.request.ollama.<type>.<model>`
+- Standalone mode: all transport/actor requires guarded behind `const_defined?(:Core, false)` so the gem works as a pure HTTP client library without AMQP
+
+### Fixed
+- `Runners::S3Models`: use `::JSON.parse` (stdlib) instead of bare `JSON.parse` which resolves to `Legion::JSON` (symbol keys) inside the `Legion::` namespace — fixes `import_from_s3` and `sync_from_s3` manifest parsing
+
 ## [0.3.0] - 2026-04-01
 
 ### Added

data/CLAUDE.md

@@ -1,44 +1,213 @@
 # lex-ollama: Ollama Integration for LegionIO
 
-**Parent**: `/Users/miverso2/rubymine/legion/extensions-ai/CLAUDE.md`
+**Repository Level 3 Documentation**
+- **Parent**: `../CLAUDE.md`
+- **Grandparent**: `../../CLAUDE.md`
 
 ## Purpose
 
-Legion Extension that connects LegionIO to Ollama, a local LLM server. Provides text generation, chat completions, embeddings, model management, and blob operations.
+Legion Extension that connects LegionIO to Ollama, a local LLM server. Provides text generation,
+chat completions, embeddings, model management, blob operations, S3 model distribution, version
+reporting, and **fleet queue subscription** for receiving routed LLM requests from the Legion bus.
 
 **GitHub**: https://github.com/LegionIO/lex-ollama
 **License**: MIT
+**Version**: 0.3.2
+**Specs**: 82 examples (12 spec files) — fleet additions add ~35 more
+
+---
 
 ## Architecture
 
 ```
 Legion::Extensions::Ollama
 ├── Runners/
-│   ├── Completions        # POST /api/generate
-│   ├── Chat               # POST /api/chat
-│   ├── Models             # CRUD + pull/push/running
-│   ├── Embeddings         # POST /api/embed
-│   ├── Blobs              # HEAD/POST /api/blobs/:digest
-│   └── Version            # GET /api/version
+│   ├── Completions    # generate, generate_stream
+│   ├── Chat           # chat, chat_stream
+│   ├── Models         # create_model, list_models, show_model, copy_model, delete_model,
+│   │                  #   pull_model, push_model, list_running
+│   ├── Embeddings     # embed
+│   ├── Blobs          # check_blob, push_blob
+│   ├── S3Models       # list_s3_models, import_from_s3, sync_from_s3, import_default_models
+│   ├── Version        # server_version
+│   └── Fleet          # handle_request (fleet dispatcher — chat/embed/generate)
 ├── Helpers/
-│   └── Client             # Faraday connection to Ollama server
-└── Client                 # Standalone client class
+│   ├── Client         # Faraday connection to Ollama server (module, factory method)
+│   ├── Errors         # error handling + with_retry
+│   └── Usage          # usage normalization (maps Ollama token/duration fields to standard shape)
+├── Client             # Standalone client class (includes all runners, holds @config)
+├── Transport/         # (loaded only when Legion::Extensions::Core is present)
+│   ├── Exchanges/
+│   │   └── LlmRequest   # references Legion::LLM::Fleet::Exchange ('llm.request')
+│   ├── Queues/
+│   │   └── ModelRequest # parametric queue — one per (type, model) pair, auto-delete
+│   └── Messages/
+│       └── LlmResponse  # Legion::LLM::Fleet::Response subclass, reply via default exchange
+└── Actor/
+    └── ModelWorker    # subscription actor — one per registered model/type
+```
+
+---
+
+## Fleet Queue Subscription
+
+### Overview
+
+When `Legion::Extensions::Core` is available, lex-ollama subscribes to model-scoped queues on the
+`llm.request` topic exchange, accepting routed inference work from other Legion fleet members
+(lex-llm-gateway, direct publishers, etc.).
+
+### Routing Key Schema
+
+```
+llm.request.ollama.<type>.<model>
+```
+
+| Segment    | Values                     | Notes                              |
+|------------|----------------------------|------------------------------------|
+| `ollama`   | literal                    | provider identifier                |
+| `type`     | `chat`, `embed`, `generate`| maps to a specific runner method   |
+| `model`    | sanitised model name       | `:` replaced with `.` (AMQP rules) |
+
+**Examples:**
+```
+llm.request.ollama.embed.nomic-embed-text
+llm.request.ollama.embed.mxbai-embed-large
+llm.request.ollama.chat.qwen3.5.27b          # was qwen3.5:27b
+llm.request.ollama.chat.llama3.2
+llm.request.ollama.generate.llama3.2
+```
+
+### Queue Strategy
+
+Each model+type combination gets its own **auto-delete queue** with a routing key that matches
+its queue name exactly. Multiple nodes carrying the same model compete fairly (no SAC) — any
+subscriber can serve. The queue name is identical to the routing key for clarity in the management UI.
+RabbitMQ policies (applied externally via Terraform) set `max-length` and
+`overflow: reject-publish` on `llm.request.*` queues. Queue priority is enabled by declaring
+`x-max-priority: 10` on the queue itself (and may also be mirrored by policy for consistency).
+
+### Configuration
+
+```yaml
+legion:
+  ollama:
+    host: "http://localhost:11434"
+    subscriptions:
+      - type: embed
+        model: nomic-embed-text
+      - type: embed
+        model: mxbai-embed-large
+      - type: chat
+        model: "qwen3.5:27b"
+      - type: chat
+        model: llama3.2
+```
+
+The extension spawns one `Actor::ModelWorker` per subscription entry at boot.
+
+### Data Flow
+
+```
+Publisher (legion-llm Fleet::Dispatcher / any fleet node)
+  │  routing_key: "llm.request.ollama.embed.nomic-embed-text"
+  │  AMQP type: 'llm.fleet.request'
+  │  Body includes: message_context { conversation_id, message_id, parent_message_id, message_seq, request_id, exchange_id }
+  ▼
+Exchange: llm.request  [topic, durable]
+  │
+  └── Queue: llm.request.ollama.embed.nomic-embed-text  [auto-delete]
+            ▼
+       Actor::ModelWorker (type=embed, model=nomic-embed-text)
+            ▼
+       Runners::Fleet#handle_request
+            │  copies message_context from request
+            ▼
+       Ollama::Client#embed(model: 'nomic-embed-text', ...)
+            ▼
+       Fleet::Response (type: 'llm.fleet.response') → reply_to queue
+            Body includes: message_context (copied), response_message_id
 ```
 
+### Standalone Mode (no Legion runtime)
+
+All transport/actor requires are guarded behind:
+```ruby
+if Legion::Extensions.const_defined?(:Core, false)
+  # transport + actor requires
+end
+```
+The gem still works as a pure HTTP client library without AMQP, exactly as before.
+
+---
+
+## Key Design Decisions
+
+- `generate_stream` and `chat_stream` yield `{ type: :delta, text: }` and `{ type: :done }` events.
+- `S3Models` runner depends on `lex-s3`. Uses SHA256 digest verification. `import_from_s3` writes
+  directly to the filesystem; `sync_from_s3` pushes blobs through the Ollama API.
+- `S3Models::OLLAMA_REGISTRY_PREFIX = 'manifests/registry.ollama.ai/library'`.
+- `Usage` helper normalizes Ollama's token/duration fields to `{ input_tokens:, output_tokens:, ... }`.
+- All runners return `{ result: body, status: code }`.
+- **`Runners::Fleet` dispatch rules:**
+  - `request_type: 'embed'` → `Client#embed`, uses `:input` then falls back to `:text`.
+  - `request_type: 'generate'` → `Client#generate`.
+  - anything else (including `'chat'` or unknown) → `Client#chat`.
+- **`Actor::ModelWorker#use_runner?` is `false`** — bypasses `Legion::Runner` / task DB entirely.
+- **Reply publishing** never raises — errors are swallowed so the AMQP ack is not blocked.
+- **Colon sanitisation** — `qwen3.5:27b` becomes `qwen3.5.27b` in queue/routing-key strings.
+
+---
+
+## Wire Protocol & Message Classes
+
+Fleet messages inherit from `Legion::LLM::Transport::Message` (defined in legion-llm), which
+extends `Legion::Transport::Message` with `message_context` propagation and LLM-specific headers.
+
+```
+Legion::Transport::Message                (platform base)
+  └── Legion::LLM::Transport::Message     (LLM base — message_context, llm_headers)
+       ├── Legion::LLM::Fleet::Request    (type: 'llm.fleet.request',  app_id: 'legion-llm')
+       ├── Legion::LLM::Fleet::Response   (type: 'llm.fleet.response', app_id: 'lex-ollama')
+       └── Legion::LLM::Fleet::Error      (type: 'llm.fleet.error',    app_id: 'lex-ollama')
+```
+
+Every fleet message carries `message_context` in the body for end-to-end tracing:
+```
+message_context:
+  conversation_id, message_id, parent_message_id, message_seq, request_id, exchange_id
+```
+
+A subset (`conversation_id`, `message_id`, `request_id`) is promoted to AMQP headers
+(`x-legion-llm-conversation-id`, etc.) for filtering without body parsing.
+
+See: `docs/plans/2026-04-08-fleet-wire-protocol.md` for full AMQP property mapping,
+platform-wide standard, and per-message-type specifications.
+
+---
+
 ## Dependencies
 
 | Gem | Purpose |
 |-----|---------|
-| faraday | HTTP client for Ollama REST API |
+| `faraday` >= 2.0 | HTTP client for Ollama REST API |
+| `lex-s3` >= 0.2 | S3 model distribution operations |
+
+Fleet transport requires Legion runtime gems (`legion-transport`, `legion-llm`, `LegionIO`) but
+those are *not* gemspec dependencies — they are expected to be present in the runtime environment.
+`legion-llm` is needed for fleet message classes (`Legion::LLM::Fleet::Request`, etc.).
+
+---
 
 ## Testing
 
 ```bash
 bundle install
-bundle exec rspec
+bundle exec rspec        # all examples
 bundle exec rubocop
 ```
 
 ---
 
 **Maintained By**: Matthew Iverson (@Esity)
+**Last Updated**: 2026-04-08

data/README.md

@@ -119,6 +119,10 @@ result[:usage]  # => { input_tokens: 1, output_tokens: 5, total_duration: ..., .
 - [LegionIO](https://github.com/LegionIO/LegionIO) framework
 - [Ollama](https://ollama.com) running locally or on a remote host
 
+## Version
+
+0.3.1
+
 ## License
 
 MIT

data/lib/legion/extensions/ollama/actors/model_worker.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Ollama
+      module Actor
+        # Subscription actor that listens on a model-scoped queue and forwards
+        # inbound LLM request messages to Runners::Fleet#handle_request.
+        #
+        # One instance is created per (request_type, model) entry in settings:
+        #
+        #   legion:
+        #     ollama:
+        #       fleet:
+        #         consumer_priority: 10
+        #       subscriptions:
+        #         - type: embed
+        #           model: nomic-embed-text
+        #         - type: chat
+        #           model: "qwen3.5:27b"
+        #
+        # The queue name and routing key both follow the schema:
+        #   llm.request.ollama.<type>.<model>
+        # where model colons are converted to dots (AMQP topic word separator).
+        class ModelWorker < Legion::Extensions::Actors::Subscription
+          attr_reader :request_type, :model_name
+
+          def initialize(request_type:, model:, **)
+            @request_type = request_type.to_s
+            @model_name   = model.to_s
+            super(**)
+          end
+
+          def runner_class
+            Legion::Extensions::Ollama::Runners::Fleet
+          end
+
+          def runner_function
+            'handle_request'
+          end
+
+          # Bypass Legion::Runner — call the runner module directly so we don't
+          # need a task record in the database for every LLM inference hop.
+          def use_runner?
+            false
+          end
+
+          # prefetch(1) is required for consumer priority to work correctly:
+          # without it, a high-priority consumer can hold multiple messages while
+          # lower-priority consumers sit idle. With prefetch=1, each consumer
+          # completes one message before RabbitMQ delivers the next, and priority
+          # determines which idle consumer gets it.
+          def prefetch
+            1
+          end
+
+          # Consumer priority from settings. Tells RabbitMQ to prefer this consumer
+          # over lower-priority ones on the same queue when multiple consumers are idle.
+          # Standard scale: GPU server = 10, Mac Studio = 5, developer laptop = 1.
+          # Defaults to 0 (equal priority) if not configured.
+          def consumer_priority
+            return 0 unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:ollama, :fleet, :consumer_priority) || 0
+          end
+
+          # Subscribe options include x-priority argument so RabbitMQ can honour
+          # consumer priority when dispatching to competing consumers.
+          def subscribe_options
+            base = begin
+              super
+            rescue NoMethodError
+              {}
+            end
+            base.merge(arguments: { 'x-priority' => consumer_priority })
+          end
+
+          # Override queue to return a model-scoped queue bound with the precise
+          # routing key for this worker's (type, model) pair.
+          def queue
+            @queue ||= build_and_bind_queue
+          end
+
+          # Enrich every inbound message with the worker's own request_type and model
+          # so Runners::Fleet#handle_request always has them, even if the sender omitted
+          # them. Also defaults message_context to {} if absent.
+          def process_message(payload, metadata, delivery_info)
+            msg = super
+            msg[:request_type]    ||= @request_type
+            msg[:model]           ||= @model_name
+            msg[:message_context] ||= {}
+            msg
+          end
+
+          private
+
+          def build_and_bind_queue
+            sanitised_model = @model_name.tr(':', '.')
+            routing_key     = "llm.request.ollama.#{@request_type}.#{sanitised_model}"
+
+            queue_obj = Transport::Queues::ModelRequest.new(
+              request_type: @request_type,
+              model:        @model_name
+            )
+            exchange_obj = Transport::Exchanges::LlmRequest.new
+            queue_obj.bind(exchange_obj, routing_key: routing_key)
+            queue_obj
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/ollama/runners/fleet.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Ollama
+      module Runners
+        # Fleet runner — handles inbound AMQP LLM request messages and dispatches
+        # them to the appropriate Ollama::Client method based on request_type.
+        #
+        # Called by Actor::ModelWorker with use_runner? = false.
+        module Fleet
+          class << self
+            # Primary entry point called by the subscription actor.
+            #
+            # @param model [String] Ollama model name, e.g. "nomic-embed-text"
+            # @param request_type [String] "chat", "embed", or "generate"
+            # @param reply_to [String, nil] routing key for the reply queue (RPC pattern)
+            # @param correlation_id [String, nil] fleet correlation ID, echoed back in reply
+            # @param message_context [Hash] tracing context — copied verbatim into the reply
+            # @param payload [Hash] remaining message keys passed to the Ollama client
+            def handle_request(model:, request_type: 'chat', reply_to: nil,
+                               correlation_id: nil, message_context: {}, **payload)
+              received_at = Time.now.utc
+
+              if payload[:stream]
+                publish_error(
+                  reply_to:        reply_to,
+                  correlation_id:  correlation_id,
+                  message_context: message_context,
+                  model:           model,
+                  request_type:    request_type,
+                  error:           {
+                    code:      'unsupported_streaming',
+                    message:   'Streaming over the fleet AMQP bus is not supported in v1',
+                    retriable: false,
+                    category:  'validation',
+                    provider:  'ollama'
+                  }
+                )
+                return { result: nil, status: 422, error: 'unsupported_streaming' }
+              end
+
+              result = dispatch(model: model, request_type: request_type, **payload)
+              returned_at = Time.now.utc
+
+              if reply_to
+                publish_reply(
+                  reply_to:        reply_to,
+                  correlation_id:  correlation_id,
+                  message_context: message_context,
+                  model:           model,
+                  request_type:    request_type,
+                  result:          result,
+                  received_at:     received_at,
+                  returned_at:     returned_at
+                )
+              end
+
+              result
+            end
+
+            # Dispatch to the correct Ollama client method by request_type.
+            #
+            # @return [Hash] { result: body, status: code } or { result: nil, status: 500, error: msg }
+            def dispatch(model:, request_type:, **payload)
+              host   = ollama_host
+              ollama = Legion::Extensions::Ollama::Client.new(host: host)
+
+              case request_type.to_s
+              when 'embed'
+                input = payload[:input] || payload[:text]
+                ollama.embed(model: model, input: input,
+                             **payload.slice(:truncate, :options, :keep_alive, :dimensions))
+              when 'generate'
+                ollama.generate(model: model, prompt: payload[:prompt],
+                                **payload.slice(:images, :format, :options, :system, :keep_alive))
+              else
+                ollama.chat(model: model, messages: payload[:messages],
+                            **payload.slice(:tools, :format, :options, :keep_alive, :think))
+              end
+            rescue StandardError => e
+              { result: nil, usage: {}, status: 500, error: e.message }
+            end
+
+            # Publish a successful fleet response to the caller's reply_to queue.
+            # Errors are swallowed so the AMQP ack path is never blocked by a broken reply.
+            def publish_reply(reply_to:, correlation_id:, message_context:, model:,
+                              request_type:, result:, received_at:, returned_at:)
+              return unless defined?(Legion::Transport)
+
+              body   = result[:result] || {}
+              usage  = result[:usage] || {}
+              status = result[:status] || 200
+              latency_ms = ((returned_at - received_at) * 1000).round
+
+              Transport::Messages::LlmResponse.new(
+                reply_to:             reply_to,
+                fleet_correlation_id: correlation_id,
+                message_context:      message_context,
+                provider:             'ollama',
+                model:                model,
+                request_type:         request_type,
+                app_id:               'lex-ollama',
+                **build_response_body(
+                  request_type: request_type,
+                  body:         body,
+                  usage:        usage,
+                  status:       status,
+                  model:        model,
+                  latency_ms:   latency_ms,
+                  received_at:  received_at,
+                  returned_at:  returned_at
+                )
+              ).publish
+            rescue StandardError
+              nil
+            end
+
+            # Publish a fleet error to the caller's reply_to queue.
+            # Errors are swallowed so the AMQP ack path is never blocked.
+            def publish_error(reply_to:, correlation_id:, message_context:, model:,
+                              request_type:, error:)
+              return unless reply_to
+              return unless defined?(Legion::Transport)
+
+              Legion::LLM::Fleet::Error.new(
+                reply_to:             reply_to,
+                fleet_correlation_id: correlation_id,
+                message_context:      message_context,
+                provider:             'ollama',
+                model:                model,
+                request_type:         request_type,
+                app_id:               'lex-ollama',
+                error:                error,
+                worker_node:          node_identity
+              ).publish
+            rescue StandardError
+              nil
+            end
+
+            private
+
+            # Build the JSON body for a successful fleet response.
+            def build_response_body(request_type:, body:, usage:, status:, model:,
+                                    latency_ms:, received_at:, returned_at:)
+              base = {
+                routing:    {
+                  provider:   'ollama',
+                  model:      model,
+                  tier:       'fleet',
+                  strategy:   'fleet_dispatch',
+                  latency_ms: latency_ms
+                },
+                tokens:     {
+                  input:  usage[:input_tokens]  || 0,
+                  output: usage[:output_tokens] || 0,
+                  total:  (usage[:input_tokens] || 0) + (usage[:output_tokens] || 0)
+                },
+                stop:       { reason: body.is_a?(Hash) ? body['done_reason'] : nil },
+                cost:       { estimated_usd: 0.0, provider: 'ollama', model: model },
+                timestamps: {
+                  received:       received_at.iso8601(3),
+                  provider_start: received_at.iso8601(3),
+                  provider_end:   returned_at.iso8601(3),
+                  returned:       returned_at.iso8601(3)
+                },
+                audit:      {
+                  'fleet:execute' => {
+                    outcome:     status == 200 ? 'success' : 'error',
+                    duration_ms: latency_ms,
+                    timestamp:   returned_at.iso8601(3)
+                  }
+                },
+                stream:     false
+              }
+
+              case request_type.to_s
+              when 'embed'
+                base.merge(
+                  embeddings: body.is_a?(Hash) ? body['embeddings'] : body
+                )
+              when 'generate'
+                base.merge(
+                  message: { role: 'assistant', content: body.is_a?(Hash) ? body['response'] : body }
+                )
+              else
+                content = body.is_a?(Hash) ? body.dig('message', 'content') : body
+                base.merge(
+                  message: { role: 'assistant', content: content }
+                )
+              end
+            end
+
+            # Resolve the Ollama host from settings, falling back to the default.
+            def ollama_host
+              return Helpers::Client::DEFAULT_HOST unless defined?(Legion::Settings)
+
+              Legion::Settings.dig(:ollama, :host) || Helpers::Client::DEFAULT_HOST
+            end
+
+            # Resolve the local node identity for worker_node in error messages.
+            def node_identity
+              return 'unknown' unless defined?(Legion::Settings)
+
+              Legion::Settings.dig(:node, :canonical_name) || 'unknown'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/ollama/runners/s3_models.rb

@@ -45,7 +45,7 @@ module Legion
             manifest_key = "#{prefix}/#{OLLAMA_REGISTRY_PREFIX}/#{name}/#{tag}"
             manifest_resp = s3.get_object(bucket: bucket, key: manifest_key)
             manifest_body = manifest_resp[:body]
-            manifest_data = JSON.parse(manifest_body)
+            manifest_data = ::JSON.parse(manifest_body)
 
             digests = []
             digests << manifest_data['config'].slice('digest', 'size')
@@ -90,7 +90,7 @@ module Legion
 
             manifest_key = "#{prefix}/#{OLLAMA_REGISTRY_PREFIX}/#{name}/#{tag}"
             manifest_resp = s3.get_object(bucket: bucket, key: manifest_key)
-            manifest_data = JSON.parse(manifest_resp[:body])
+            manifest_data = ::JSON.parse(manifest_resp[:body])
 
             digests = []
             digests << manifest_data['config']['digest']

data/lib/legion/extensions/ollama/transport/exchanges/llm_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Ollama
+      module Transport
+        module Exchanges
+          # Thin alias that delegates exchange definition to Legion::LLM::Fleet::Exchange.
+          # This class exists solely so Ollama::Transport topology introspection has a
+          # local reference without importing legion-llm internals directly.
+          class LlmRequest < Legion::LLM::Fleet::Exchange
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/ollama/transport/messages/llm_response.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Ollama
+      module Transport
+        module Messages
+          # Published back to the caller's reply_to queue after a fleet request is processed.
+          #
+          # Inherits Legion::LLM::Fleet::Response which:
+          #   - sets type: 'llm.fleet.response'
+          #   - sets routing_key to @options[:reply_to]
+          #   - publishes via AMQP default exchange ('')
+          #   - propagates message_context into body and headers
+          #   - generates message_id with 'resp_' prefix
+          #
+          # This class only overrides app_id so audit records and the wire protocol
+          # correctly identify lex-ollama as the worker component.
+          class LlmResponse < Legion::LLM::Fleet::Response
+            def app_id
+              'lex-ollama'
+            end
+          end
+        end
+      end
+    end
+  end
+end