lex-llm-openai 0.4.1 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e0bcb314dd98bb72b108f3f92a05ceb40dd8fc125e3972712674537e5baa2a9
-  data.tar.gz: b9fd92e6d25f2e9949fa5b5e1a7d79f8d9ed04a197b873a0b754d309dc30aef6
+  metadata.gz: 4091bfdcfbcd60f52453e29e42e30a4564edd48dabcd9b0f8edadfa68440f52b
+  data.tar.gz: 0de0b799f80f47f937a9ecdc797996c4c0d3e64784fc518bf0b5de8628df135b
 SHA512:
-  metadata.gz: 4e3886489304539fda6fe6566aa7f596682bcd480944822eebf473ff638a0c3f47b8f88243444afaf3e2ccd58a6b1699c4918b627eb859fcef7a409884536294
-  data.tar.gz: efaaea62fada60fe7f598426c59028d6461ad6afb5c935d9e3a77b43b22a6d9ae0e76577ae75a9b5e96b40f6f9bff8cc1dbf881a082fab3a88c93f00516bfd67
+  metadata.gz: 0abdd81c00439b7ccba758adbd7f8576e83ce5e367673ce2092708dc3f61290c406db462e0736e56402957c32f47b0fd781bdcf6486508a5b8486ab48f6d2edf
+  data.tar.gz: 29b4b768e0bd91aee7cd05283b62caf93d4ffbd6215063c7fa480d3ed1a2b164341e669d6badcb4e7f804db55e9500e81c016eef5f4a7223c20039730942ec37

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.4.5 - 2026-06-17
+
+### Changed
+- **Policy-aware default model** — `default_model` is no longer a hardcoded literal forced via `||=`. The `gpt-5.5` fallback is now a named `DEFAULT_MODEL` constant applied through `Provider.policy_safe_default_model`, so a configured `model_whitelist`/`model_blacklist` is never overridden: if neither the configured default nor the fallback is permitted, `default_model` is left unset and routing resolves an allowed discovered model instead. Requires lex-llm >= 0.5.4.
+
+## 0.4.4 - 2026-06-16
+
+- dependency updates, code quality improvements
+
+## 0.4.3 - 2026-06-15
+
+- **CapabilityPolicy integration** — CAPABILITY_MAP fed as `:provider_catalog` source. Settings overrides at provider/instance/model level supported.
+
+## 0.4.2 — 2026-06-13
+
+- **Gemfile cleanup** — Remove local path overrides; dependencies resolve from gemspec via rubygems.
+- **Capabilities** — Add canonical `:tools` to capability declarations.
+- **Bug fix** — Extract nested `cached_tokens` from usage details (G26).
+- 153 examples, 0 failures; 16 files, 0 rubocop offenses.
+
 ## 0.4.1 — 2026-06-10
 
 - Canonical translator (`Translator`): `render_request`, `parse_response`, `parse_chunk`, `capabilities` — provider-boundary contract per N×N routing Amendment A

data/Gemfile

@@ -2,12 +2,6 @@
 
 source 'https://rubygems.org'
 
-group :test do
-  transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
-  gem 'legion-transport', path: transport_path if File.directory?(transport_path)
-  # lex-llm resolved from rubygems (>= 0.5.0) via gemspec - no local path dep
-end
-
 gemspec
 
 group :development do

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.0'
+  spec.add_dependency 'lex-llm', '>= 0.5.4'
 end

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

@@ -37,6 +37,13 @@ module Legion
               return unless defined?(Legion::LLM::Discovery)
 
               Legion::LLM::Discovery.refresh_discovered_models!(provider: :openai)
+
+              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!
+              end
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'openai.actor.discovery_refresh')
             end

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

@@ -17,43 +17,43 @@ module Legion
           # the raw /v1/models response.
           CAPABILITY_MAP = {
             'gpt-4o' => {
-              capabilities: %i[completion streaming function_calling vision structured_output],
+              capabilities: %i[completion streaming function_calling tools vision structured_output],
               modalities_input: %w[text image audio],
               modalities_output: %w[text],
               context_window: 128_000
             },
             'gpt-4.1' => {
-              capabilities: %i[completion streaming function_calling vision structured_output],
+              capabilities: %i[completion streaming function_calling tools vision structured_output],
               modalities_input: %w[text image],
               modalities_output: %w[text],
               context_window: 1_047_576
             },
             'gpt-4' => {
-              capabilities: %i[completion streaming function_calling vision],
+              capabilities: %i[completion streaming function_calling tools vision],
               modalities_input: %w[text image],
               modalities_output: %w[text],
               context_window: 128_000
             },
             'gpt-5' => {
-              capabilities: %i[completion streaming function_calling vision structured_output reasoning],
+              capabilities: %i[completion streaming function_calling tools vision structured_output reasoning],
               modalities_input: %w[text image],
               modalities_output: %w[text],
               context_window: 1_047_576
             },
             'o4' => {
-              capabilities: %i[completion streaming function_calling vision reasoning],
+              capabilities: %i[completion streaming function_calling tools vision reasoning],
               modalities_input: %w[text image],
               modalities_output: %w[text],
               context_window: 200_000
             },
             'o3' => {
-              capabilities: %i[completion streaming function_calling vision reasoning],
+              capabilities: %i[completion streaming function_calling tools vision reasoning],
               modalities_input: %w[text image],
               modalities_output: %w[text],
               context_window: 200_000
             },
             'o1' => {
-              capabilities: %i[completion streaming function_calling vision reasoning],
+              capabilities: %i[completion streaming function_calling tools vision reasoning],
               modalities_input: %w[text image],
               modalities_output: %w[text],
               context_window: 200_000
@@ -211,6 +211,36 @@ 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')
+            []
+          end
+
+          # ── CapabilityPolicy integration ─────────────────────────────────
+          # Maps raw CAPABILITY_MAP symbol arrays to the boolean hash format
+          # that CapabilityPolicy.resolve expects as :provider_catalog.
+          CATALOG_CAPABILITY_MAPPING = {
+            streaming: :streaming,
+            function_calling: :tools,
+            tools: :tools,
+            vision: :vision,
+            structured_output: :structured_output,
+            reasoning: :thinking,
+            embedding: :embeddings,
+            image_generation: :image,
+            audio_transcription: :audio_transcription,
+            audio_generation: :audio_speech
+          }.freeze
+
           private
 
           def build_model_infos(body)
@@ -248,6 +278,115 @@ module Legion
             }
           end
 
+          def offering_from_model(model_info)
+            policy = resolve_model_policy(model_info)
+
+            Legion::Extensions::Llm::Routing::ModelOffering.new(
+              offering_attrs_for(model_info, policy)
+            )
+          end
+
+          def resolve_model_policy(model_info)
+            catalog = capabilities_to_boolean_hash(capability_entry_for(model_info.id)[:capabilities])
+
+            Legion::Extensions::Llm::CapabilityPolicy.resolve(
+              real: {},
+              provider_catalog: catalog,
+              probe: {},
+              provider_envelope: {},
+              provider_config: provider_capability_config,
+              instance_config: instance_capability_config,
+              model_config: model_capability_config(model_info.id)
+            )
+          end
+
+          def offering_attrs_for(model_info, policy)
+            {
+              provider_family: :openai,
+              instance_id: config.respond_to?(:instance_id) ? config.instance_id : :default,
+              transport: :http,
+              tier: :frontier,
+              model: model_info.id,
+              canonical_model_alias: model_info.respond_to?(:name) ? model_info.name : nil,
+              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,
+              metadata: { capability_sources: policy[:sources] }
+            }
+          end
+
+          def capabilities_to_boolean_hash(capability_symbols)
+            return {} unless capability_symbols.is_a?(Array)
+
+            result = {}
+            capability_symbols.each do |sym|
+              mapped = CATALOG_CAPABILITY_MAPPING[sym]
+              result[mapped] = true if mapped
+            end
+            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)
+            end
+            :unknown
+          end
+
+          def infer_usage_type(model_info)
+            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)
+
+            :inference
+          end
+
           def fetch_model_detail(model_name)
             entry = capability_entry_for(model_name)
             ctx = entry[:context_window]

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

@@ -287,7 +287,8 @@ module Legion
           end
 
           def render_openai_tool_calls(tool_calls)
-            Array(tool_calls).map do |tc|
+            tc_array = tool_calls.is_a?(Hash) ? tool_calls.values : Array(tool_calls)
+            tc_array.map do |tc|
               args = tc.arguments.is_a?(String) ? tc.arguments : Legion::JSON.generate(tc.arguments || {})
 
               {
@@ -353,7 +354,24 @@ module Legion
           def parse_usage(raw)
             return nil unless raw&.any?
 
-            Canonical::Usage.from_hash(raw)
+            normalized = raw.dup
+            normalized[:cache_read_tokens] ||= extract_nested_cached_tokens(raw)
+            normalized[:thinking_tokens] ||= extract_nested_reasoning_tokens(raw)
+            Canonical::Usage.from_hash(normalized)
+          end
+
+          def extract_nested_cached_tokens(raw)
+            raw.dig(:prompt_tokens_details, :cached_tokens) ||
+              raw.dig('prompt_tokens_details', 'cached_tokens') ||
+              raw.dig(:input_tokens_details, :cached_tokens) ||
+              raw.dig('input_tokens_details', 'cached_tokens')
+          end
+
+          def extract_nested_reasoning_tokens(raw)
+            raw.dig(:completion_tokens_details, :reasoning_tokens) ||
+              raw.dig('completion_tokens_details', 'reasoning_tokens') ||
+              raw.dig(:output_tokens_details, :reasoning_tokens) ||
+              raw.dig('output_tokens_details', 'reasoning_tokens')
           end
 
           def map_stop_reason(raw)

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

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

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

@@ -4,6 +4,7 @@ require 'legion/extensions/llm'
 require 'legion/extensions/llm/openai/provider'
 require 'legion/extensions/llm/openai/translator'
 require 'legion/extensions/llm/openai/version'
+require_relative 'openai/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -15,13 +16,17 @@ module Legion
         extend Legion::Extensions::Llm::AutoRegistration
 
         PROVIDER_FAMILY = :openai
+        # Provider's preferred default when the operator configures none. Used only
+        # as a fallback and only when the configured model policy permits it
+        # (see resolve_default_model) — a whitelist/blacklist is never overridden.
+        DEFAULT_MODEL = 'gpt-5.5'
 
         def self.default_settings
           ::Legion::Extensions::Llm.provider_settings(
             family: PROVIDER_FAMILY,
             instance: {
               endpoint: 'https://api.openai.com',
-              default_model: 'gpt-5.5',
+              default_model: DEFAULT_MODEL,
               tier: :frontier,
               transport: :http,
               credentials: {
@@ -40,10 +45,7 @@ module Legion
               fleet: {
                 enabled: false,
                 respond_to_requests: false,
-                capabilities: %i[chat stream_chat embed image],
-                lanes: [],
-                concurrency: 4,
-                queue_suffix: nil
+                capabilities: %i[chat stream_chat embed image]
               }
             }
           )
@@ -102,10 +104,10 @@ module Legion
             candidates[name.to_sym] = normalized.merge(tier: :frontier)
           end
 
-          # 8. Dedup + inject default_model
+          # 8. Dedup + inject a policy-aware default_model
           discovered = CredentialSources.dedup_credentials(candidates).transform_values do |config|
             sanitized = sanitize_instance_config(config)
-            sanitized[:default_model] ||= 'gpt-5.5'
+            sanitized[:default_model] = resolve_default_model(sanitized)
             sanitized
           end
           instance_names = discovered.keys.sort_by(&:to_s).join(', ')
@@ -113,6 +115,15 @@ module Legion
           discovered
         end
 
+        # Resolve a default_model that never violates the configured model policy
+        # (whitelist/blacklist stays authoritative over the DEFAULT_MODEL fallback).
+        def self.resolve_default_model(config)
+          provider_class.policy_safe_default_model(
+            configured: config[:default_model], fallback: DEFAULT_MODEL,
+            **provider_class.model_policy(config, PROVIDER_FAMILY)
+          )
+        end
+
         def self.settings_instances(config)
           return {} unless config.is_a?(Hash)
 
@@ -135,8 +146,7 @@ module Legion
           config.except(:api_key, :organization_id, :project_id)
         end
 
-        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options) if
-          Legion::Extensions::Llm::Configuration.respond_to?(:register_provider_options)
+        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options)
       end
     end
   end

metadata

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