lex-llm-openai 0.4.5 → 0.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4091bfdcfbcd60f52453e29e42e30a4564edd48dabcd9b0f8edadfa68440f52b
-  data.tar.gz: 0de0b799f80f47f937a9ecdc797996c4c0d3e64784fc518bf0b5de8628df135b
+  metadata.gz: 137435c2996f9aa9c56c884f616c824561ef2493c30a3c113a2a8261eb37c88c
+  data.tar.gz: 81b9d2b79bdeb8f708338ce9bd66d923a5165643f2416be5bfe730db53c41a61
 SHA512:
-  metadata.gz: 0abdd81c00439b7ccba758adbd7f8576e83ce5e367673ce2092708dc3f61290c406db462e0736e56402957c32f47b0fd781bdcf6486508a5b8486ab48f6d2edf
-  data.tar.gz: 29b4b768e0bd91aee7cd05283b62caf93d4ffbd6215063c7fa480d3ed1a2b164341e669d6badcb4e7f804db55e9500e81c016eef5f4a7223c20039730942ec37
+  metadata.gz: 5cf576c1d1bae53ce4acaae572a984ebe2c02032b570ed720fc596f6b820567905c0de57592d9addbf47ba72d30867847a18213ec11be7a81cf315699c88bc3c
+  data.tar.gz: 151b3e313e710f56678eb1a2e042d6208cf35dd3a00a4b93a27107ec11e2aa74200aa5e3b492beba1db89096a5e3dd1b4fb5ae7165a6ce4fa54b84b12ac26d3c

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.4.9] - 2026-07-24
+
+### Fixed
+- **Translator no longer discards content when `finish_reason` is present on SSE chunk.** Previously returned a done chunk immediately when finish_reason was set, silently dropping any content, reasoning, or tool_call data on the same event. Now checks for content fields first and only emits done when the delta is truly empty. Passes `stop_reason` and `usage` through to content/tool_call chunks.
+
+## [0.4.8] - 2026-06-20
+
+### Fixed
+- Stop bulk-publishing OpenAI model availability from `list_models`; discovery now emits one registry event per seen model from the shared `lex-llm` policy-filter path so blocked models stay observable without duplicate publishes.
+
+## [0.4.7] - 2026-06-20
+
+### Fixed
+- Normalize OpenAI offering capabilities through the canonical `lex-llm` contract so `completion`, `embedding`, `thinking`, image, and audio capabilities survive discovery without provider-specific vocabulary drift.
+- Move provider/instance/model capability override extraction onto the shared base provider implementation.
+
+## [0.4.6] - 2026-06-19
+
+### Changed
+- Adopt `Legion::Extensions::Llm::Inventory::ScopedRefresher` mixin (lex-llm 0.6.0). Discovery
+  refresh actors now write directly to the live `Inventory` catalog via `Inventory.write_lane`.
+- Pin `lex-llm >= 0.6.0` and `legion-llm >= 0.14.0` in gemspec.
+- Standard `weight: 100` default added to provider instance settings schema.
+
 ## 0.4.5 - 2026-06-17
 
 ### Changed

data/lex-llm-openai.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.5.4'
+  spec.add_dependency 'lex-llm', '>= 0.6.0'
 end

data/lib/legion/extensions/llm/openai/actors/discovery_refresh.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 begin
   require 'legion/extensions/actors/every'
 rescue LoadError => e
@@ -8,6 +10,12 @@ end
 
 return unless defined?(Legion::Extensions::Actors::Every)
 
+begin
+  require 'legion/extensions/llm/inventory/scoped_refresher'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
 module Legion
   module Extensions
     module Llm
@@ -17,7 +25,11 @@ module Legion
           class DiscoveryRefresh < Legion::Extensions::Actors::Every
             include Legion::Logging::Helper
 
-            REFRESH_INTERVAL = 1800
+            if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+              include Legion::Extensions::Llm::Inventory::ScopedRefresher
+            end
+
+            def self.every_seconds = 3600
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -27,26 +39,135 @@ module Legion
             def generate_task?  = false
 
             def time
-              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+              return self.class.every_seconds unless defined?(Legion::Settings)
 
-              Legion::Settings.dig(:extensions, :llm, :openai, :discovery_interval) || REFRESH_INTERVAL
+              Legion::Settings.dig(:extensions, :llm, :openai, :discovery_interval) || self.class.every_seconds
             end
 
-            def manual
-              log.debug('[openai][discovery_refresh] refreshing model list')
-              return unless defined?(Legion::LLM::Discovery)
+            def scope_key
+              { provider: :openai }
+            end
 
-              Legion::LLM::Discovery.refresh_discovered_models!(provider: :openai)
+            def compute_lanes_for_scope
+              return [] unless defined?(Legion::LLM::Call::Registry)
 
-              if defined?(Legion::LLM::Router) && Legion::LLM::Router.respond_to?(:populate_auto_rules)
-                Legion::LLM::Router.populate_auto_rules(Legion::LLM::Discovery.discovered_instances)
-              end
-              if defined?(Legion::LLM::Inventory) && Legion::LLM::Inventory.respond_to?(:invalidate_offerings_cache!)
-                Legion::LLM::Inventory.invalidate_offerings_cache!
+              instances = Legion::LLM::Call::Registry.all_instances.select do |e|
+                (e[:provider] || '').to_sym == :openai
               end
+
+              lanes = []
+              instances.each { |entry| lanes.concat(lanes_for_instance(entry)) }
+              lanes
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true,
+                                  operation: 'openai.actor.discovery_refresh.compute_lanes')
+              []
+            end
+
+            def credential_hash
+              settings = Legion::Settings.dig(:extensions, :llm, :openai) || {}
+              Digest::SHA256.hexdigest(settings[:api_key].to_s + settings[:instances].to_s)[0, 16]
+            rescue StandardError
+              'unknown'
+            end
+
+            def manual
+              tick_if_scoped_refresher
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'openai.actor.discovery_refresh')
             end
+
+            private
+
+            def tick_if_scoped_refresher
+              return unless defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+              return unless self.class.ancestors.include?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+
+              tick
+            end
+
+            def lanes_for_instance(instance_entry) # rubocop:disable Metrics/CyclomaticComplexity
+              adapter = instance_entry[:adapter]
+              return [] unless adapter.respond_to?(:discover_offerings)
+
+              instance_id = instance_entry[:instance] || instance_entry[:instance_id] ||
+                            instance_entry[:id] || :default
+              lanes = []
+
+              Array(adapter.discover_offerings(live: true)).each do |raw_offering|
+                offering = offering_to_hash(raw_offering)
+                next unless offering
+
+                lane = build_lane(offering, instance_id)
+                lanes << lane
+                fleet_lane = maybe_fleet_lane(offering, lane)
+                lanes << fleet_lane if fleet_lane
+              end
+
+              lanes
+            end
+
+            def offering_to_hash(offering)
+              return nil if offering.nil?
+              return offering if offering.is_a?(Hash)
+
+              hash = offering.to_h
+              hash[:type] ||= hash[:usage_type]
+              hash[:enabled] = offering.respond_to?(:enabled?) ? offering.enabled? : true
+              hash
+            end
+
+            def build_lane(offering, instance_id)
+              tier = offering[:tier] || :frontier
+              type = offering_type(offering)
+              lane_fields = { tier: tier, provider_family: :openai, instance_id: instance_id,
+                              type: type, model: offering[:model] }
+              {
+                id: Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(lane_fields),
+                tier: tier,
+                provider_family: :openai,
+                instance_id: instance_id,
+                model: offering[:model],
+                canonical_model_alias: offering[:canonical_model_alias],
+                type: type,
+                capabilities: normalize_capabilities(offering[:capabilities]),
+                limits: offering[:limits] || {},
+                enabled: offering.fetch(:enabled, true),
+                cost: offering[:cost]
+              }
+            end
+
+            def maybe_fleet_lane(offering, lane)
+              return nil unless offering_type(offering) == :inference
+
+              settings = Legion::Settings.dig(:extensions, :llm, :openai) || {}
+              return nil unless settings[:fleet]&.dig(:dispatch, :enabled)
+
+              fleet_fields = {
+                tier: :fleet,
+                provider_family: lane[:provider_family],
+                instance_id: lane[:instance_id],
+                type: lane[:type],
+                model: lane[:model]
+              }
+              lane.merge(
+                id: Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(fleet_fields),
+                tier: :fleet
+              )
+            end
+
+            def offering_type(offering)
+              %i[embed embedding].include?(offering[:type]) ? :embedding : :inference
+            end
+
+            def normalize_capabilities(caps)
+              if defined?(Legion::Extensions::Llm::Inventory::Capabilities) &&
+                 Legion::Extensions::Llm::Inventory::Capabilities.respond_to?(:normalize)
+                Legion::Extensions::Llm::Inventory::Capabilities.normalize(caps)
+              else
+                Array(caps)
+              end
+            end
           end
         end
       end

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

@@ -202,8 +202,7 @@ module Legion
             log.debug('Listing OpenAI models')
             raw = connection.get(models_url)
             models = build_model_infos(raw.body)
-            log.debug { "Discovered #{models.size} OpenAI models; publishing registry availability" }
-            self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
+            log.debug { "Discovered #{models.size} OpenAI models" }
             models
           rescue StandardError => e
             handle_exception(e, level: :error, handled: true,
@@ -211,17 +210,17 @@ module Legion
             raise
           end
 
-          def discover_offerings(live: false, **)
-            models = if live
-                       @cached_models = list_models
-                     else
-                       Array(@cached_models)
-                     end
-            offerings = models.filter_map { |model_info| offering_from_model(model_info) }
-            log.debug { "built #{offerings.size} OpenAI offering(s) live=#{live}" }
-            offerings
-          rescue StandardError => e
-            handle_exception(e, level: :warn, handled: true, operation: 'openai.discover_offerings')
+          def discover_offerings(live: false, raise_on_unreachable: false, **filters)
+            return filter_cached_offerings(Array(@cached_offerings), filters) unless live
+
+            provider_health = health(live:)
+            @cached_offerings = discover_live_offerings(filters, provider_health, live:)
+            log_discover_complete(@cached_offerings)
+            @cached_offerings
+          rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+            log.warn("[#{slug}] instance=#{provider_instance_id} unreachable: #{e.message}")
+            raise if raise_on_unreachable
+
             []
           end
 
@@ -229,20 +228,57 @@ module Legion
           # Maps raw CAPABILITY_MAP symbol arrays to the boolean hash format
           # that CapabilityPolicy.resolve expects as :provider_catalog.
           CATALOG_CAPABILITY_MAPPING = {
+            completion: :completion,
             streaming: :streaming,
             function_calling: :tools,
             tools: :tools,
             vision: :vision,
             structured_output: :structured_output,
             reasoning: :thinking,
-            embedding: :embeddings,
+            embedding: :embedding,
             image_generation: :image,
             audio_transcription: :audio_transcription,
             audio_generation: :audio_speech
           }.freeze
 
+          def discover_live_offerings(filters, provider_health, live:)
+            readiness = discovery_registry_readiness(provider_health, live:)
+            Array(list_models(live:, **filters)).filter_map do |model|
+              self.class.registry_publisher.publish_models_async([model], readiness:)
+              next unless model_matches_filters?(model, filters)
+              next unless model_allowed?(model.id)
+
+              log_model_discovered(model)
+              offering_from_model(model, health: provider_health)
+            end
+          end
+
+          def log_model_discovered(model)
+            log.debug(
+              "[#{slug}] instance=#{provider_instance_id} action=model_discovered " \
+              "model=#{model.id} family=#{model.family}"
+            )
+          end
+
+          def log_discover_complete(offerings)
+            log.info(
+              "[#{slug}] instance=#{provider_instance_id} action=discover_complete " \
+              "model_count=#{Array(offerings).size}"
+            )
+          end
+
           private
 
+          def discovery_registry_readiness(provider_health, live:)
+            {
+              provider: slug.to_sym,
+              configured: configured?,
+              ready: provider_health[:ready] == true,
+              live: live,
+              health: provider_health
+            }
+          end
+
           def build_model_infos(body)
             body.fetch('data', []).map do |raw_model|
               id = raw_model.fetch('id')
@@ -278,11 +314,11 @@ module Legion
             }
           end
 
-          def offering_from_model(model_info)
+          def offering_from_model(model_info, health: {})
             policy = resolve_model_policy(model_info)
 
             Legion::Extensions::Llm::Routing::ModelOffering.new(
-              offering_attrs_for(model_info, policy)
+              offering_attrs_for(model_info, policy, health:)
             )
           end
 
@@ -300,23 +336,32 @@ module Legion
             )
           end
 
-          def offering_attrs_for(model_info, policy)
+          def offering_attrs_for(model_info, policy, health: {})
             {
               provider_family: :openai,
-              instance_id: config.respond_to?(:instance_id) ? config.instance_id : :default,
-              transport: :http,
-              tier: :frontier,
+              instance_id: offering_instance_id,
+              transport: offering_transport,
+              tier: offering_tier,
               model: model_info.id,
-              canonical_model_alias: model_info.respond_to?(:name) ? model_info.name : nil,
+              canonical_model_alias: offering_alias(model_info),
               model_family: infer_model_family(model_info.id),
               usage_type: infer_usage_type(model_info),
               capabilities: policy[:capabilities],
               capability_sources: policy[:sources],
               limits: { context_window: model_info.context_length }.compact,
+              health: health,
               metadata: { capability_sources: policy[:sources] }
             }
           end
 
+          def offering_instance_id
+            config.respond_to?(:instance_id) ? config.instance_id : :default
+          end
+
+          def offering_alias(model_info)
+            model_info.respond_to?(:name) ? model_info.name : nil
+          end
+
           def capabilities_to_boolean_hash(capability_symbols)
             return {} unless capability_symbols.is_a?(Array)
 
@@ -328,49 +373,6 @@ module Legion
             result
           end
 
-          def provider_capability_config
-            return {} unless defined?(Legion::Extensions::Llm::CredentialSources)
-
-            conf = Legion::Extensions::Llm::CredentialSources.setting(:extensions, :llm, :openai)
-            conf.is_a?(Hash) ? conf.to_h.except(:instances, 'instances') : {}
-          rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'openai.provider_capability_config')
-            {}
-          end
-
-          def instance_capability_config
-            cfg = config
-            result = {}
-            %i[capabilities enable_thinking enable_tools enable_streaming enable_vision enable_embeddings
-               thinking_flag tools_flag streaming_flag vision_flag embedding_flag embeddings_flag
-               tool_flag images_flag image_flag].each do |key|
-              next unless cfg.respond_to?(key)
-
-              val = cfg.send(key)
-              result[key] = val unless val.nil?
-            rescue StandardError
-              next
-            end
-            result
-          end
-
-          def model_capability_config(model_id)
-            models_conf = fetch_models_config
-            return {} unless models_conf.respond_to?(:to_h)
-
-            models_conf.to_h[model_id.to_s] || models_conf.to_h[model_id.to_sym] || {}
-          rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'openai.model_capability_config')
-            {}
-          end
-
-          def fetch_models_config
-            return config.models if config.respond_to?(:models)
-            return config[:models] if config.respond_to?(:[])
-
-            nil
-          end
-
           def infer_model_family(model_id)
             CAPABILITY_MAP.each_key do |prefix|
               return prefix.tr('-', '_').to_sym if model_id.start_with?(prefix)
@@ -382,7 +384,7 @@ module Legion
             caps = model_info.respond_to?(:capabilities) ? Array(model_info.capabilities) : []
             return :embedding if caps.include?(:embedding)
             return :moderation if caps.include?(:moderation)
-            return :image if caps.include?(:image_generation)
+            return :image if caps.include?(:image)
 
             :inference
           end

data/lib/legion/extensions/llm/openai/translator.rb

@@ -116,16 +116,26 @@ module Legion
             finish_reason = choice['finish_reason']
             usage_raw = data['usage']
 
-            return build_done_chunk(data, finish_reason, usage_raw) if finish_reason
+            chunk_stop_reason = finish_reason ? map_stop_reason(finish_reason) : nil
+            chunk_usage = finish_reason && usage_raw ? parse_usage(usage_raw) : nil
+
             return parse_error_chunk(data) if data['error']
 
             reasoning = delta['reasoning_content'] || delta['reasoning']
             content = delta['content']
 
-            return build_thinking_chunk(reasoning, data['id']) if reasoning
-            return build_text_chunk(content, data['id']) if content
+            if reasoning
+              return build_thinking_chunk(reasoning, data['id'], stop_reason: chunk_stop_reason,
+                                                                 usage: chunk_usage)
+            end
+            return build_text_chunk(content, data['id'], stop_reason: chunk_stop_reason, usage: chunk_usage) if content
+
+            tc_chunk = parse_tool_call_delta(delta, data, stop_reason: chunk_stop_reason, usage: chunk_usage)
+            return tc_chunk if tc_chunk
+
+            return build_done_chunk(data, finish_reason, usage_raw) if finish_reason
 
-            parse_tool_call_delta(delta, data)
+            nil
           rescue StandardError => e
             handle_exception(e, level: :error, handled: true, operation: 'openai.translator.parse_chunk')
             Canonical::Chunk.error_chunk(
@@ -403,21 +413,25 @@ module Legion
             )
           end
 
-          def build_thinking_chunk(reasoning, request_id)
+          def build_thinking_chunk(reasoning, request_id, stop_reason: nil, usage: nil)
             Canonical::Chunk.thinking_delta(
               delta: reasoning,
-              request_id: request_id
+              request_id: request_id,
+              stop_reason: stop_reason,
+              usage: usage
             )
           end
 
-          def build_text_chunk(content, request_id)
+          def build_text_chunk(content, request_id, stop_reason: nil, usage: nil)
             Canonical::Chunk.text_delta(
               delta: content,
-              request_id: request_id
+              request_id: request_id,
+              stop_reason: stop_reason,
+              usage: usage
             )
           end
 
-          def parse_tool_call_delta(delta, data)
+          def parse_tool_call_delta(delta, data, stop_reason: nil, usage: nil)
             raw_tc = delta['tool_calls']
             return nil unless raw_tc&.any?
 
@@ -432,7 +446,9 @@ module Legion
 
             Canonical::Chunk.tool_call_delta(
               tool_call: tool_call,
-              request_id: data['id']
+              request_id: data['id'],
+              stop_reason: stop_reason,
+              usage: usage
             )
           end
 

data/lib/legion/extensions/llm/openai/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Openai
-        VERSION = '0.4.5'
+        VERSION = '0.4.9'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-openai
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.9
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.4
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.4
+        version: 0.6.0
 description: OpenAI provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com