lex-llm 0.3.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21bb44444f871870151b379672c39b043c36233ee0b7d634660a7fe021f355b6
-  data.tar.gz: 2bc64a7a18d4304179e7465c99e21fdf584a9e4dd54860b207bf8d8c87e738cf
+  metadata.gz: 6f3fc1bac35781a8134a6d24d7467a790cdd506244cfd4f0e66955a4fa82ceb9
+  data.tar.gz: 0c1cdfe9dee8e21c5b9bba0a01b12f5ef41e30b46c73ff8d22ccc35d621818a9
 SHA512:
-  metadata.gz: 930d418014199a5f3b34bf505555e54462e2e590c11475859221d9a83c2def586f547c8341f813cfab03d6677ddbc8a66e06edc9f36e6bb6ffea05d36e40ce0b
-  data.tar.gz: 66201e1d6405692d6da1fbb38d294b7632a0ef2ca42f1578c548746a5caeb3d3a25d1d37347e33f88d628408d962707d4ab254038cc97d0ad27b89bafa42b0e8
+  metadata.gz: 4592bdc8998415754bfce42444be4168fc05eacd3d20be7872c3f5ed2ef3384cd44a9027cb23bb7f3f0e8dda8b12451f51332b16d2a4611975e950da0a5da2af
+  data.tar.gz: a90e2831742bc0af3c0d540f8459434d8fb287cb5504dbaf2be6c22425aceff4d929ff5c230485951d6669b46be79dd439d0f80a688272b52b8f494adab83b4f

data/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## 0.4.2 - 2026-05-06
+
+- Remove the temporary settings logger wrapper and lazy-load fleet transport envelopes so `lex-llm` boot does not force `legion-transport` loading.
+
+## 0.4.1 - 2026-05-06
+
+- Make `AutoRegistration` a pure provider discovery mixin and remove upward `Legion::LLM::Call::Registry` mutation hooks.
+- Add provider alias metadata so `legion-llm` can register compatibility provider families without provider require-time side effects.
+- Pass live discovery flags and filters through from `Provider#discover_offerings` to `#list_models`.
+- Merge provider-specific embedding params into canonical `Provider#embed` request payloads.
+
+## 0.4.0 - 2026-05-06
+
+- Set the coordinated sweep dependency floor for provider-owned fleet responders.
+- Make `Provider#discover_offerings(live: false)` serve only cached live discovery results so inventory reads do not probe provider endpoints.
+
+## 0.3.6 - 2026-05-06
+
+- Replace shared fleet request, response, and error envelopes with strict fleet protocol v2 fields.
+- Reject legacy fleet envelope fields and publish provider replies through the AMQP default exchange reply queue with optional mandatory routing and publisher confirms.
+
+## 0.3.5 - 2026-05-06
+
+- Add shared response normalization value objects for chat, stream, embedding, and thinking extraction.
+- Strip provider thinking from caller-visible OpenAI-compatible completion content, including malformed trailing close-tag output.
+- Preserve provider reasoning metadata while tolerating streaming tool-call deltas without optional function names.
+
+## 0.3.4 - 2026-05-06
+
+- Add shared provider contract and unsupported capability error namespace for lex-llm provider gems.
+- Require keyword provider embed/count token calls and validate provider settings instance nesting.
+- Move shared fleet defaults under nested consumer/auth settings.
+
+## 0.3.3 - 2026-05-03
+
+- Fix OpenAI-compatible streaming to keep split `<think>` tag content out of streamed assistant content.
+- Strip leaked assistant thinking from outbound OpenAI-compatible history, including dangling close-tag content from prior responses.
+- Tolerate incomplete streaming tool-call deltas that omit `function.name`.
+
+## 0.3.2 - 2026-05-03
+
+- Fix AutoRegistration to pass the discovered instance id into provider adapter config for instance-aware model offerings
+
 ## 0.3.1 - 2026-05-02
 
 - Fix AutoRegistration to pass tier and capabilities metadata to Call::Registry on registration

data/README.md

@@ -37,7 +37,7 @@ Expected provider gems include:
 - `lex-llm-mlx`
 - `lex-llm-bedrock`
 - `lex-llm-vertex`
-- `lex-llm-azure`
+- `lex-llm-azure-foundry`
 
 ## Install
 
@@ -48,7 +48,7 @@ gem 'lex-llm'
 Provider extensions should declare `lex-llm` as a gemspec dependency:
 
 ```ruby
-spec.add_dependency 'lex-llm', '>= 0.1.6'
+spec.add_dependency 'lex-llm', '>= 0.4.0'
 ```
 
 For local development across LegionIO repos, prefer a local path override in the app or test `Gemfile`, not a permanent git dependency in the gemspec.
@@ -297,6 +297,22 @@ At minimum, a provider extension should define:
 
 Provider extensions should avoid duplicating shared classes, schema logic, fleet lane construction, JSON handling, or common request/response objects.
 
+Canonical provider calls are keyword-based:
+
+```ruby
+provider.chat(messages:, model:, tools: [], temperature: nil, params: {}, headers: {}, schema: nil, thinking: nil)
+provider.stream_chat(messages:, model:, tools: [], temperature: nil, params: {}, headers: {}, schema: nil, thinking: nil) { |chunk| ... }
+provider.embed(text:, model:, dimensions: nil, params: {}, headers: {})
+provider.image(prompt:, model:, size:, with: nil, mask: nil, params: {})
+provider.count_tokens(messages:, model:, params: {})
+provider.health(live: false)
+provider.discover_offerings(live: false, **filters)
+```
+
+Provider responses should normalize through the shared response objects before they reach callers. Visible assistant text and provider reasoning are separate values: provider-specific thinking fields, OpenAI-compatible `reasoning_content`, and literal `<think>...</think>` text are removed from caller-visible content and preserved as thinking metadata when present.
+
+Fleet envelopes also live here. `FleetRequest`, `FleetResponse`, and `FleetError` are protocol-v2 transport messages with `operation`, `request_id`, `correlation_id`, `idempotency_key`, `message_context`, and signed-token fields. Provider gems should consume and publish these shared envelopes instead of defining local fleet message shapes.
+
 All providers inherit `#readiness(live: false)`, which returns configured state, provider locality, API base, endpoint helpers, and non-live health metadata without probing remote services. Providers with a cheap health endpoint can pass `live: true` to include that endpoint response. OpenAI-compatible providers also inherit shared model-list parsing that maps discovered models into normalized capabilities and modalities for Legion routing.
 
 ## Schema Status

data/lex-llm.gemspec

@@ -37,6 +37,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-json', '>= 1.2.1'
   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 'marcel', '~> 1'
   spec.add_dependency 'ruby_llm-schema', '~> 0'
   spec.add_dependency 'zeitwerk', '~> 2'

data/lib/legion/extensions/llm/auto_registration.rb

@@ -3,9 +3,9 @@
 module Legion
   module Extensions
     module Llm
-      # Mixin that lex-llm-* provider modules `extend` to get shared
-      # registration boilerplate.  The provider only needs to override
-      # `discover_instances` — everything else is handled here.
+      # Mixin that lex-llm-* provider modules `extend` to expose shared
+      # discovery metadata. Registration into Legion::LLM is owned by
+      # legion-llm so loaded providers can be rediscovered after reloads.
       #
       # Prerequisites on the extending module:
       #   - `PROVIDER_FAMILY` constant (Symbol, e.g. :ollama)
@@ -16,39 +16,10 @@ module Legion
           {}
         end
 
-        # Calls discover_instances, creates a LexLLMAdapter for each,
-        # and registers into Call::Registry.
-        #
-        # Strips :tier and :capabilities from config before passing to
-        # the adapter (these are metadata, not connection config).
-        #
-        # Guarded: no-op when Legion::LLM::Call::Registry is not loaded.
-        def register_discovered_instances
-          return unless defined?(Legion::LLM::Call::Registry)
-
-          instances = discover_instances
-          instances.each do |instance_id, config|
-            registry_config = config.except(:tier, :capabilities)
-            adapter = Legion::LLM::Call::LexLLMAdapter.new(
-              self::PROVIDER_FAMILY, provider_class, instance_config: registry_config
-            )
-            meta = { tier: config[:tier], capabilities: config[:capabilities] || [] }
-            Legion::LLM::Call::Registry.register(
-              self::PROVIDER_FAMILY, adapter, instance: instance_id, metadata: meta
-            )
-          end
-        rescue StandardError => e
-          log.warn "[#{self::PROVIDER_FAMILY}] self-registration failed: #{e.message}" if respond_to?(:log)
-        end
-
-        # Deregisters all instances for this provider and re-runs discovery.
-        #
-        # Guarded: no-op when Legion::LLM::Call::Registry is not loaded.
-        def rediscover!
-          return unless defined?(Legion::LLM::Call::Registry)
-
-          Legion::LLM::Call::Registry.deregister_provider(self::PROVIDER_FAMILY)
-          register_discovered_instances
+        # Optional provider-family aliases that legion-llm should register
+        # against the same discovered provider instances.
+        def provider_aliases
+          []
         end
       end
     end

data/lib/legion/extensions/llm/embedding.rb

@@ -25,7 +25,7 @@ module Legion
                                                            config: config)
           model_id = model.id
 
-          provider_instance.embed(text, model: model_id, dimensions:)
+          provider_instance.embed(text:, model: model_id, dimensions:)
         end
       end
     end

data/lib/legion/extensions/llm/error.rb

@@ -27,6 +27,20 @@ module Legion
       class ModelNotFoundError < StandardError; end
       class UnsupportedAttachmentError < StandardError; end
 
+      # Backward-compatible unsupported-capability error alias.
+      class UnsupportedCapabilityError < Errors::UnsupportedCapability
+        def initialize(message = nil, provider: nil, capability: nil, model: nil)
+          if provider && capability
+            super(provider:, capability:, model:)
+          else
+            @provider = provider
+            @capability = capability
+            @model = model
+            StandardError.instance_method(:initialize).bind_call(self, message)
+          end
+        end
+      end
+
       # Error classes for different HTTP status codes
       class BadRequestError < Error; end
       class ForbiddenError < Error; end

data/lib/legion/extensions/llm/errors/unsupported_capability.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Errors
+        # Raised when a provider receives a canonical call for an unsupported capability.
+        class UnsupportedCapability < StandardError
+          attr_reader :provider, :capability, :model
+
+          def initialize(provider:, capability:, model: nil)
+            @provider = provider
+            @capability = capability
+            @model = model
+            super("Provider #{provider} does not support #{capability}#{" for #{model}" if model}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/fleet/default_exchange_reply.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative 'publish_safety'
+
+module Legion
+  module Extensions
+    module Llm
+      module Fleet
+        # Publishes correlated fleet replies directly to the caller's reply queue.
+        module DefaultExchangeReply
+          include PublishSafety
+
+          DEFAULT_REPLY_PUBLISH_OPTIONS = {
+            mandatory: false,
+            publisher_confirm: false,
+            spool: false,
+            return_result: true
+          }.freeze
+
+          def publish(options = nil)
+            raise unless @valid
+
+            requested_options = DEFAULT_REPLY_PUBLISH_OPTIONS.merge(@options).merge(options || {})
+            return_result = return_publish_result?(requested_options)
+            publish_options = reply_publish_options(requested_options)
+            validate_payload_size
+            default_exchange = channel.default_exchange
+            return_state = {}
+            install_return_listener(default_exchange, requested_options, return_state)
+            prepare_publisher_confirms(default_exchange, requested_options)
+            default_exchange.publish(encode_message, **publish_options)
+            return nil unless return_result
+
+            publish_result(default_exchange, requested_options.merge(publish_options), return_state)
+          rescue Bunny::ConnectionClosedError, Bunny::ChannelAlreadyClosed, Bunny::ChannelError,
+                 Bunny::NetworkErrorWrapper, IOError, Timeout::Error => e
+            handle_exception(e, level: :warn, handled: true, operation: 'llm.fleet.reply.publish')
+            reply_publish_failure_result(e, publish_options || @options)
+          end
+
+          private
+
+          def reply_publish_failure_result(error, options)
+            {
+              status: :failed,
+              accepted: false,
+              error_class: error.class.name,
+              error: error.message,
+              routing_key: options[:routing_key] || routing_key,
+              message_id: message_id,
+              correlation_id: correlation_id
+            }.compact
+          end
+
+          def reply_publish_options(options)
+            {
+              routing_key: routing_key,
+              content_type: options[:content_type] || content_type,
+              content_encoding: options[:content_encoding] || content_encoding,
+              type: options[:type] || type,
+              priority: options[:priority] || priority,
+              expiration: options[:expiration] || expiration,
+              headers: reply_headers(options),
+              persistent: options.key?(:persistent) ? options[:persistent] : persistent,
+              message_id: message_id,
+              correlation_id: correlation_id,
+              reply_to: reply_to,
+              app_id: options[:app_id] || app_id,
+              timestamp: timestamp,
+              mandatory: options[:mandatory] == true
+            }.compact
+          end
+
+          def reply_headers(options)
+            options[:headers] ? headers.merge(options[:headers]) : headers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/fleet/envelope_validation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'protocol'
+
+module Legion
+  module Extensions
+    module Llm
+      module Fleet
+        # Shared validation helpers for strict fleet protocol v2 envelopes.
+        module EnvelopeValidation
+          LEGACY_OPTIONS = %i[schema_version request_type fleet_correlation_id].freeze
+
+          private
+
+          def reject_legacy_options!
+            LEGACY_OPTIONS.each do |key|
+              if @options.key?(key) || @options.key?(key.to_s)
+                raise ArgumentError, "#{key} is not supported by fleet protocol v2"
+              end
+            end
+          end
+
+          def require_option!(key)
+            return if @options.key?(key) && !@options[key].nil?
+
+            raise ArgumentError, "#{key} is required"
+          end
+
+          def require_protocol_version!
+            version = @options.fetch(:protocol_version, Fleet::Protocol::VERSION)
+            return if version == Fleet::Protocol::VERSION
+
+            raise ArgumentError, "protocol_version must be #{Fleet::Protocol::VERSION}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/fleet/protocol.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Fleet
+        module Protocol
+          VERSION = 2
+          REQUEST_TYPE = 'llm.fleet.request'
+          RESPONSE_TYPE = 'llm.fleet.response'
+          ERROR_TYPE = 'llm.fleet.error'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/fleet/publish_safety.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Fleet
+        # Publish-result helpers kept local to fleet messages so they work with older legion-transport releases.
+        module PublishSafety
+          private
+
+          def return_publish_result?(options)
+            options[:return_result] == true || options[:mandatory] == true || options[:publisher_confirm] == true ||
+              options[:spool] == false
+          end
+
+          def install_return_listener(exchange_dest, options, return_state)
+            return unless options[:mandatory] == true
+
+            return_channel = publish_channel(exchange_dest)
+            return unless return_channel.respond_to?(:on_return)
+
+            expected_correlation_id = correlation_id
+            expected_message_id = message_id
+            return_channel.on_return do |return_info, properties, _content|
+              next unless returned_message_matches?(
+                properties,
+                correlation_id: expected_correlation_id,
+                message_id: expected_message_id
+              )
+
+              record_return!(return_state, return_info)
+            end
+          end
+
+          def returned_message_matches?(properties, correlation_id:, message_id:)
+            return false if property_mismatch?(properties, :correlation_id, correlation_id)
+            return false if property_mismatch?(properties, :message_id, message_id)
+
+            true
+          end
+
+          def property_mismatch?(properties, key, expected)
+            return false unless expected
+            return false unless properties.respond_to?(key)
+
+            value = properties.public_send(key)
+            value && value != expected
+          end
+
+          def record_return!(return_state, return_info)
+            return_state[:returned] = true
+            return_state[:reply_code] = return_info.reply_code if return_info.respond_to?(:reply_code)
+            return_state[:reply_text] = return_info.reply_text if return_info.respond_to?(:reply_text)
+          end
+
+          def prepare_publisher_confirms(exchange_dest, options)
+            return unless options[:publisher_confirm] == true
+
+            confirm_channel = publish_channel(exchange_dest)
+            confirm_channel.confirm_select if confirm_channel.respond_to?(:confirm_select)
+          end
+
+          def publish_result(exchange_dest, options, return_state)
+            status = confirm_publish(exchange_dest, options)
+            status = :unroutable if return_state[:returned]
+            {
+              status: status,
+              accepted: status == :accepted,
+              exchange: exchange_name(exchange_dest),
+              routing_key: options[:routing_key] || routing_key || '',
+              message_id: message_id,
+              return_reply_code: return_state[:reply_code],
+              return_reply_text: return_state[:reply_text],
+              correlation_id: correlation_id
+            }.compact
+          end
+
+          def publish_failure_result(status, error, options)
+            {
+              status: status,
+              accepted: false,
+              error_class: error.class.name,
+              error: error.message,
+              routing_key: options[:routing_key] || routing_key || '',
+              message_id: message_id,
+              correlation_id: correlation_id
+            }.compact
+          end
+
+          def confirm_publish(exchange_dest, options)
+            return :accepted unless options[:publisher_confirm] == true
+
+            confirm_channel = publish_channel(exchange_dest)
+            return :accepted unless confirm_channel.respond_to?(:wait_for_confirms)
+
+            timeout = options[:publish_confirm_timeout_ms]
+            confirmed = if timeout
+                          confirm_channel.wait_for_confirms(timeout.to_f / 1000.0)
+                        else
+                          confirm_channel.wait_for_confirms
+                        end
+            confirmed == false ? :nacked : :accepted
+          rescue Timeout::Error => e
+            handle_exception(e, level: :warn, handled: true, operation: 'llm.fleet.publish.confirm')
+            :confirm_timeout
+          end
+
+          def publish_channel(exchange_dest)
+            return exchange_dest.channel if exchange_dest.respond_to?(:channel)
+
+            channel
+          end
+
+          def exchange_name(exchange_dest)
+            return exchange_dest.name if exchange_dest.respond_to?(:name)
+
+            exchange_dest.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/message.rb

@@ -80,12 +80,18 @@ module Legion
             content: content,
             model_id: model_id,
             tool_calls: tool_calls,
-            tool_call_id: tool_call_id,
-            thinking: thinking&.text,
-            thinking_signature: thinking&.signature
+            tool_call_id: tool_call_id
           }.merge(tokens ? tokens.to_h : {}).compact
         end
 
+        def to_internal_h
+          to_h.merge(
+            thinking: thinking&.text,
+            thinking_signature: thinking&.signature,
+            raw: raw
+          ).compact
+        end
+
         def instance_variables
           super - [:@raw]
         end

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

@@ -39,17 +39,17 @@ module Legion
             messages.map do |message|
               {
                 role: message.role.to_s,
-                content: openai_content(message.content),
+                content: openai_content(message.content, role: message.role),
                 tool_call_id: message.tool_call_id,
                 tool_calls: format_openai_tool_calls(message.tool_calls)
               }.compact
             end
           end
 
-          def openai_content(content)
+          def openai_content(content, role:)
             return content.format if content.is_a?(Legion::Extensions::Llm::Content::Raw)
-            return content unless content.respond_to?(:attachments)
-            return content.text.to_s if content.attachments.empty?
+            return sanitize_openai_text(content, role:) unless content.respond_to?(:attachments)
+            return sanitize_openai_text(content.text.to_s, role:) if content.attachments.empty?
 
             openai_content_parts(content)
           end
@@ -63,6 +63,12 @@ module Legion
             parts
           end
 
+          def sanitize_openai_text(text, role:)
+            return text unless role.to_sym == :assistant && text.is_a?(String)
+
+            Responses::ThinkingExtractor.extract(text).content
+          end
+
           def format_openai_tool_calls(tool_calls)
             return nil unless tool_calls&.any?
 
@@ -135,18 +141,29 @@ module Legion
           end
 
           def extract_thinking_from_completion(message)
-            reasoning = message['reasoning_content'] || message['reasoning']
-            content = message['content']
+            extraction = Responses::ThinkingExtractor.extract(
+              message['content'],
+              metadata: thinking_metadata(message)
+            )
 
-            if reasoning
-              [content, Thinking.build(text: reasoning)]
-            elsif content.is_a?(String) && content.include?('<think>')
-              think_text = content[%r{<think>(.*?)</think>}m, 1]
-              clean = content.gsub(%r{<think>.*?</think>}m, '').strip
-              [clean, Thinking.build(text: think_text)]
-            else
-              [content, nil]
-            end
+            [
+              extraction.content,
+              Thinking.build(
+                text: extraction.thinking,
+                signature: extraction.signature
+              )
+            ]
+          end
+
+          def thinking_metadata(message)
+            {
+              reasoning_content: message['reasoning_content'],
+              reasoning: message['reasoning'],
+              thinking: message['thinking'],
+              thinking_text: message['thinking_text'],
+              thinking_signature: message['thinking_signature'],
+              reasoning_signature: message['reasoning_signature']
+            }.compact
           end
 
           def build_chunk(data)
@@ -173,39 +190,23 @@ module Legion
 
             if reasoning
               [content, Thinking.build(text: reasoning)]
-            elsif content.is_a?(String) && content.include?('<think>')
-              clean, think_text = split_think_tags(content)
-              [clean, Thinking.build(text: think_text)]
             else
               [content, nil]
             end
           end
 
-          def split_think_tags(text) # rubocop:disable Metrics/PerceivedComplexity
-            if text.match?(%r{<think>.*</think>}m)
-              thinking = text[%r{<think>(.*?)</think>}m, 1]
-              clean = text.gsub(%r{<think>.*?</think>}m, '').strip
-              [clean.empty? ? nil : clean, thinking]
-            elsif text.start_with?('<think>')
-              [nil, text.delete_prefix('<think>')]
-            elsif text.include?('</think>')
-              parts = text.split('</think>', 2)
-              [parts[1]&.strip.then { |s| s&.empty? ? nil : s }, parts[0]]
-            else
-              [text, nil]
-            end
-          end
-
           def parse_tool_calls(tool_calls)
             return nil unless tool_calls&.any?
 
             tool_calls.to_h do |call|
               function = call.fetch('function', {})
-              name = function.fetch('name')
+              name = function['name']
+              id = call['id'] || name || call['index']
+              key = name || id
               [
-                name.to_sym,
+                key.to_s.to_sym,
                 Legion::Extensions::Llm::ToolCall.new(
-                  id: call['id'] || name,
+                  id: id&.to_s,
                   name: name,
                   arguments: parse_tool_arguments(function['arguments'])
                 )