lex-llm-openai 0.4.1 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e0bcb314dd98bb72b108f3f92a05ceb40dd8fc125e3972712674537e5baa2a9
-  data.tar.gz: b9fd92e6d25f2e9949fa5b5e1a7d79f8d9ed04a197b873a0b754d309dc30aef6
+  metadata.gz: 7bb7451045c6e85e6e89657665065fe502888f49982d3dc43a53fdcb1bf4ebcd
+  data.tar.gz: 05e91bb97ec042142b126b310e9e05dcfb99fe1ae999b8595f7924102106d592
 SHA512:
-  metadata.gz: 4e3886489304539fda6fe6566aa7f596682bcd480944822eebf473ff638a0c3f47b8f88243444afaf3e2ccd58a6b1699c4918b627eb859fcef7a409884536294
-  data.tar.gz: efaaea62fada60fe7f598426c59028d6461ad6afb5c935d9e3a77b43b22a6d9ae0e76577ae75a9b5e96b40f6f9bff8cc1dbf881a082fab3a88c93f00516bfd67
+  metadata.gz: a7bdaf1e6de4518d02d1f0bc6af5ddcd39392f4fd8153902ce0414264ec773e2295ad14b8508984ed8140f96742081b1e76f16c2843dd4667e59d25fb558bf3a
+  data.tar.gz: d5dfe88b242d5b9ab7d3c27621c1761fd7e5a8a6958dfadcafe20be3e7a89a9f7c33f4b21bcda2574bc29e0ef7ea025b9f905f4d01d9e45c0de2aecc8f22648b

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 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/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.4'
       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
@@ -40,10 +41,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]
               }
             }
           )
@@ -135,8 +133,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.4
 platform: ruby
 authors:
 - LegionIO