lex-llm-openai 0.1.8 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 923d77b5cf761e20eccb817d66dd36bec5310842f1216c2b403432bf84bf11fa
-  data.tar.gz: e84b863710db389adf98f1b06783c46e4e4b7797c51889026c62939a3e3ad9a6
+  metadata.gz: 3cd48c5acd857910771717afe92892f537270d62a6f6d24d0f71e2b5805abb9d
+  data.tar.gz: c8f1a0644cb7cf1fe993f6d17b5aba3167e56d8f44f04fe0e0d6afe8d70a7146
 SHA512:
-  metadata.gz: 3ea2f8c543f3e8cbdf55a158bb0033d1711b34b3114ea8ebbccc530d398ac3931e95d3c729be869eac5070dac773edec62e3de1dc94b3c00a4560c6b6a998cbe
-  data.tar.gz: 5672bc7469d4a09a12c85fcd343c8008748ccb6a90f85dc54cfdf7feb9d81721a026aa91a11d555b826159fbe61a528732301cf19ab63470800068faa1971a42
+  metadata.gz: 2f5a9d6f495bb5fac304ef891d5f2f93353ff0d6909c54c506a448030e67791f7b79fbffb546e8b7cf94b5d8d8eef1f4b8122bd5df7115e47ff537baa33e8483
+  data.tar.gz: 7f40adfce35ab368b2db2d82a603fe48f2de269e13a093cab8adc15a946b80e2d02792fd97cf400895f55a18529f140d630e7dd4264d1f0799aa3328dd71908d

data/.rubocop.yml

@@ -12,7 +12,11 @@ Metrics/BlockLength:
   Exclude:
     - "*.gemspec"
     - spec/**/*
+Metrics/ClassLength:
+  Max: 200
 Metrics/MethodLength:
   Enabled: false
+RSpec/ExampleLength:
+  Max: 10
 RSpec/MultipleExpectations:
   Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.3.0 - 2026-05-01
+
+- Add auto-discovery via CredentialSources and AutoRegistration from lex-llm 0.3.0
+- Self-register discovered instances into Call::Registry at require-time
+- Require lex-llm >= 0.3.0
+
+
+## [0.2.0] - 2026-04-30
+- **BREAKING**: Adopt base contract from lex-llm 0.1.9; require `lex-llm >= 0.1.9`
+- Replace `provider_settings`-based `default_settings` with flat provider defaults (enabled, default_model, api_key, etc.)
+- Remove deprecated `Provider.register` call; configuration options are now registered at class-load time
+- Delete local `RegistryPublisher` and `RegistryEventBuilder`; use parameterized base classes from lex-llm
+- Delete local `transport/` directory (exchanges, messages); use shared transport from lex-llm
+- Add static `CAPABILITY_MAP` for known OpenAI model families; `list_models` now returns `Model::Info` structs directly
+- `list_models` no longer delegates to `parse_list_models_response`; builds `Model::Info` via the static capability map
+
 ## [0.1.8] - 2026-04-30
 - Add Legion::Logging::Helper to all modules and classes for structured observability
 - Replace bare rescue blocks with handle_exception for unified error telemetry

data/lex-llm-openai.gemspec

@@ -26,5 +26,5 @@ 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 'lex-llm', '>= 0.1.5'
+  spec.add_dependency 'lex-llm', '>= 0.3.0'
 end

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

@@ -9,7 +9,84 @@ module Legion
         # OpenAI provider implementation for the Legion::Extensions::Llm base provider contract.
         class Provider < Legion::Extensions::Llm::Provider
           include Legion::Extensions::Llm::Provider::OpenAICompatible
-          include Legion::Logging::Helper if defined?(Legion::Logging::Helper)
+          include Legion::Logging::Helper
+
+          # ── Static capability map for known OpenAI model families ──────
+          # Maps model-id prefixes to a set of capabilities and modality
+          # vectors. Used by list_models to build Model::Info structs from
+          # the raw /v1/models response.
+          CAPABILITY_MAP = {
+            'gpt-4o' => {
+              capabilities: %i[completion streaming function_calling vision structured_output],
+              modalities_input: %w[text image audio],
+              modalities_output: %w[text]
+            },
+            'gpt-4.1' => {
+              capabilities: %i[completion streaming function_calling vision structured_output],
+              modalities_input: %w[text image],
+              modalities_output: %w[text]
+            },
+            'gpt-4' => {
+              capabilities: %i[completion streaming function_calling vision],
+              modalities_input: %w[text image],
+              modalities_output: %w[text]
+            },
+            'gpt-5' => {
+              capabilities: %i[completion streaming function_calling vision structured_output reasoning],
+              modalities_input: %w[text image],
+              modalities_output: %w[text]
+            },
+            'o4' => {
+              capabilities: %i[completion streaming function_calling vision reasoning],
+              modalities_input: %w[text image],
+              modalities_output: %w[text]
+            },
+            'o3' => {
+              capabilities: %i[completion streaming function_calling vision reasoning],
+              modalities_input: %w[text image],
+              modalities_output: %w[text]
+            },
+            'o1' => {
+              capabilities: %i[completion streaming function_calling vision reasoning],
+              modalities_input: %w[text image],
+              modalities_output: %w[text]
+            },
+            'text-embedding-' => {
+              capabilities: %i[embedding],
+              modalities_input: %w[text],
+              modalities_output: %w[embeddings]
+            },
+            'omni-moderation' => {
+              capabilities: %i[moderation],
+              modalities_input: %w[text image],
+              modalities_output: %w[moderation]
+            },
+            'text-moderation' => {
+              capabilities: %i[moderation],
+              modalities_input: %w[text],
+              modalities_output: %w[moderation]
+            },
+            'gpt-image' => {
+              capabilities: %i[image_generation],
+              modalities_input: %w[text image],
+              modalities_output: %w[image]
+            },
+            'dall-e' => {
+              capabilities: %i[image_generation],
+              modalities_input: %w[text],
+              modalities_output: %w[image]
+            },
+            'whisper' => {
+              capabilities: %i[audio_transcription],
+              modalities_input: %w[audio],
+              modalities_output: %w[text]
+            },
+            'tts' => {
+              capabilities: %i[audio_generation],
+              modalities_input: %w[text],
+              modalities_output: %w[audio]
+            }
+          }.freeze
 
           class << self
             attr_writer :registry_publisher
@@ -30,7 +107,7 @@ module Legion
             def capabilities = Capabilities
 
             def registry_publisher
-              @registry_publisher ||= RegistryPublisher.new
+              @registry_publisher ||= Legion::Extensions::Llm::RegistryPublisher.new(provider_family: :openai)
             end
           end
 
@@ -95,32 +172,66 @@ module Legion
           def images_url(with: nil, mask: nil) = super
 
           def retrieve_model(model)
-            log.info("Retrieving model: #{model}") if respond_to?(:log)
+            log.info("Retrieving model: #{model}")
             connection.get("#{models_url}/#{model}").body
           rescue StandardError => e
-            if respond_to?(:handle_exception)
-              handle_exception(e, level: :error, handled: true,
-                                  operation: 'retrieve_model')
-            end
+            handle_exception(e, level: :error, handled: true,
+                                operation: 'retrieve_model')
             raise
           end
 
           def list_models
-            log.info('Listing OpenAI models') if respond_to?(:log)
-            super.tap do |models|
-              log.info("Discovered #{models.size} OpenAI models") if respond_to?(:log)
-              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
-            end
+            log.info('Listing OpenAI models')
+            raw = connection.get(models_url)
+            models = build_model_infos(raw.body)
+            log.info("Discovered #{models.size} OpenAI models")
+            self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
+            models
           rescue StandardError => e
-            if respond_to?(:handle_exception)
-              handle_exception(e, level: :error, handled: true,
-                                  operation: 'list_models')
-            end
+            handle_exception(e, level: :error, handled: true,
+                                operation: 'list_models')
             raise
           end
 
           private
 
+          def build_model_infos(body)
+            body.fetch('data', []).map do |raw_model|
+              id = raw_model.fetch('id')
+              cap_entry = capability_entry_for(id)
+
+              Legion::Extensions::Llm::Model::Info.new(
+                id: id,
+                name: id,
+                provider: :openai,
+                capabilities: cap_entry[:capabilities],
+                modalities_input: cap_entry[:modalities_input],
+                modalities_output: cap_entry[:modalities_output],
+                metadata: {
+                  created_at: model_created_at(raw_model['created']),
+                  raw: raw_model
+                }.compact
+              )
+            end
+          end
+
+          def capability_entry_for(model_id)
+            CAPABILITY_MAP.each do |prefix, entry|
+              return entry if model_id.start_with?(prefix)
+            end
+
+            # Fallback for unknown models: assume chat-capable
+            {
+              capabilities: %i[completion streaming],
+              modalities_input: %w[text],
+              modalities_output: %w[text]
+            }
+          end
+
+          def model_created_at(value)
+            value.is_a?(Numeric) ? Time.at(value).utc : value
+          end
+
           def maybe_normalize_temperature(temperature, model)
             model_id = model.id.to_s
             return nil if model_id.include?('-search')
@@ -133,3 +244,10 @@ module Legion
     end
   end
 end
+
+# Register configuration options so Legion::Extensions::Llm::Configuration knows about them.
+if Legion::Extensions::Llm::Configuration.respond_to?(:register_provider_options)
+  Legion::Extensions::Llm::Configuration.register_provider_options(
+    Legion::Extensions::Llm::Openai::Provider.configuration_options
+  )
+end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Openai
-        VERSION = '0.1.8'
+        VERSION = '0.3.0'
       end
     end
   end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/llm'
-require 'legion/extensions/llm/openai/registry_event_builder'
-require 'legion/extensions/llm/openai/registry_publisher'
 require 'legion/extensions/llm/openai/provider'
 require 'legion/extensions/llm/openai/version'
 
@@ -12,34 +10,81 @@ module Legion
       # Openai provider extension namespace.
       module Openai
         extend ::Legion::Extensions::Core if ::Legion::Extensions.const_defined?(:Core, false)
-        extend ::Legion::Logging::Helper if defined?(::Legion::Logging::Helper)
+        extend ::Legion::Logging::Helper
+        extend Legion::Extensions::Llm::AutoRegistration
 
         PROVIDER_FAMILY = :openai
 
         def self.default_settings
-          ::Legion::Extensions::Llm.provider_settings(
-            family: PROVIDER_FAMILY,
-            instance: {
-              endpoint: 'https://api.openai.com',
-              tier: :frontier,
-              transport: :http,
-              credentials: { api_key: 'env://OPENAI_API_KEY' },
-              usage: { inference: true, embedding: true, moderation: true, image: true, audio: true },
-              limits: { concurrency: 4 }
-            }
-          )
+          {
+            enabled: false,
+            default_model: 'gpt-4o',
+            api_key: nil,
+            organization_id: nil,
+            project_id: nil,
+            model_whitelist: [],
+            model_blacklist: [],
+            model_cache_ttl: 3600,
+            tls: { enabled: false, verify: :peer },
+            instances: {}
+          }
         end
 
         def self.provider_class
           Provider
         end
+
+        def self.discover_instances # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          candidates = {}
+
+          # 1. OPENAI_API_KEY environment variable
+          env_key = CredentialSources.env('OPENAI_API_KEY')
+          candidates[:env] = { openai_api_key: env_key, tier: :frontier } if env_key
+
+          # 2. CODEX_API_KEY environment variable
+          codex_env_key = CredentialSources.env('CODEX_API_KEY')
+          candidates[:codex_env] = { openai_api_key: codex_env_key, tier: :frontier } if codex_env_key
+
+          # 3. Codex bearer token (~/.codex/auth.json chatgpt mode)
+          codex_tok = CredentialSources.codex_token
+          candidates[:codex] = { openai_api_key: codex_tok, tier: :frontier } if codex_tok
+
+          # 4. Codex OPENAI_API_KEY from ~/.codex/auth.json
+          codex_key = CredentialSources.codex_openai_key
+          candidates[:codex_key] = { openai_api_key: codex_key, tier: :frontier } if codex_key
+
+          # 5. Claude config openaiApiKey
+          claude_key = CredentialSources.claude_config_value(:openaiApiKey)
+          candidates[:claude] = { openai_api_key: claude_key, tier: :frontier } if claude_key
+
+          # 6. Extension settings
+          settings_config = CredentialSources.setting(:extensions, :llm, :openai)
+          if settings_config.is_a?(Hash) && !settings_config.empty?
+            settings_key = settings_config[:api_key] || settings_config['api_key']
+            if settings_key
+              candidates[:settings] = settings_config.merge(
+                openai_api_key: settings_key,
+                tier: :frontier
+              )
+            end
+          end
+
+          # 7. Gateway instances from extension settings
+          gateways = CredentialSources.setting(:extensions, :llm, :openai, :gateways)
+          if gateways.is_a?(Hash)
+            gateways.each do |name, config|
+              next unless config.is_a?(Hash)
+
+              candidates[name.to_sym] = config.merge(tier: :openai_compat)
+            end
+          end
+
+          # 8. Dedup
+          CredentialSources.dedup_credentials(candidates)
+        end
       end
     end
   end
 end
 
-Legion::Extensions::Llm::Provider.register(Legion::Extensions::Llm::Openai::PROVIDER_FAMILY,
-                                           Legion::Extensions::Llm::Openai::Provider)
-if defined?(Legion::Logging::Helper) && Legion::Extensions::Llm::Openai.respond_to?(:log)
-  Legion::Extensions::Llm::Openai.log.info('Registered OpenAI provider for :openai family')
-end
+Legion::Extensions::Llm::Openai.register_discovered_instances

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-openai
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.3.0
 platform: ruby
 authors:
 - LegionIO
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.3.0
 description: OpenAI provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -84,10 +84,6 @@ files:
 - lex-llm-openai.gemspec
 - lib/legion/extensions/llm/openai.rb
 - lib/legion/extensions/llm/openai/provider.rb
-- lib/legion/extensions/llm/openai/registry_event_builder.rb
-- lib/legion/extensions/llm/openai/registry_publisher.rb
-- lib/legion/extensions/llm/openai/transport/exchanges/llm_registry.rb
-- lib/legion/extensions/llm/openai/transport/messages/registry_event.rb
 - lib/legion/extensions/llm/openai/version.rb
 homepage: https://github.com/LegionIO/lex-llm-openai
 licenses:

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Openai
-        # Builds sanitized lex-llm registry envelopes for OpenAI provider state.
-        class RegistryEventBuilder
-          include Legion::Logging::Helper if defined?(Legion::Logging::Helper)
-
-          def model_available(model, readiness:)
-            registry_event_class.available(
-              model_offering(model),
-              runtime: runtime_metadata,
-              health: model_health(readiness),
-              metadata: model_metadata(model)
-            )
-          end
-
-          private
-
-          def model_offering(model)
-            {
-              provider_family: :openai,
-              provider_instance: provider_instance,
-              transport: :http,
-              model: model.id,
-              usage_type: usage_type_for(model),
-              capabilities: Array(model.capabilities).map(&:to_sym),
-              limits: model_limits(model),
-              metadata: { lex: :llm_openai, model_name: model.name }.compact
-            }
-          end
-
-          def model_health(readiness)
-            ready = readiness.fetch(:ready, true) == true
-            { ready:, status: ready ? :available : :degraded }
-          end
-
-          def model_metadata(model)
-            { extension: :lex_llm_openai, provider: :openai, model_type: model.type }
-          end
-
-          def runtime_metadata
-            { node: provider_instance }
-          end
-
-          def model_limits(model)
-            {
-              context_window: model.context_window,
-              max_output_tokens: model.max_output_tokens
-            }.compact
-          end
-
-          def usage_type_for(model)
-            model.type == 'embedding' ? :embedding : :inference
-          end
-
-          def provider_instance
-            configured_node = (::Legion::Settings.dig(:node, :canonical_name) if defined?(::Legion::Settings))
-            value = configured_node.to_s.strip
-            value.empty? ? :openai : value.to_sym
-          rescue StandardError => e
-            if respond_to?(:handle_exception)
-              handle_exception(e, level: :debug, handled: true,
-                                  operation: 'provider_instance')
-            end
-            :openai
-          end
-
-          def registry_event_class
-            ::Legion::Extensions::Llm::Routing::RegistryEvent
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Openai
-        # Best-effort publisher for OpenAI provider availability events.
-        class RegistryPublisher
-          include Legion::Logging::Helper if defined?(Legion::Logging::Helper)
-
-          APP_ID = 'lex-llm-openai'
-
-          def initialize(builder: RegistryEventBuilder.new)
-            @builder = builder
-          end
-
-          def publish_models_async(models, readiness:)
-            log.info("Publishing #{Array(models).size} model(s) to llm.registry") if respond_to?(:log)
-            schedule do
-              Array(models).each do |model|
-                publish_event(@builder.model_available(model, readiness:))
-              end
-            end
-          end
-
-          private
-
-          def schedule(&)
-            return false unless publishing_available?
-
-            Thread.new do
-              Thread.current.abort_on_exception = false
-              yield
-            rescue StandardError => e
-              handle_exception(e, level: :debug, handled: true, operation: 'schedule') if respond_to?(:handle_exception)
-            end
-          rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'schedule') if respond_to?(:handle_exception)
-            false
-          end
-
-          def publish_event(event)
-            return false unless publishing_available?
-
-            message_class.new(event:, app_id: APP_ID).publish(spool: false)
-          rescue StandardError => e
-            if respond_to?(:handle_exception)
-              handle_exception(e, level: :warn, handled: true,
-                                  operation: 'publish_event')
-            end
-            false
-          end
-
-          def publishing_available?
-            return false unless registry_event_available?
-            return false unless transport_message_available?
-            return true unless defined?(::Legion::Transport::Connection)
-            return true unless ::Legion::Transport::Connection.respond_to?(:session_open?)
-
-            ::Legion::Transport::Connection.session_open?
-          rescue StandardError => e
-            if respond_to?(:handle_exception)
-              handle_exception(e, level: :debug, handled: true,
-                                  operation: 'publishing_available?')
-            end
-            false
-          end
-
-          def registry_event_available?
-            defined?(::Legion::Extensions::Llm::Routing::RegistryEvent)
-          end
-
-          def transport_message_available?
-            return true if message_class_defined?
-            return false unless defined?(::Legion::Transport::Message) && defined?(::Legion::Transport::Exchange)
-
-            require 'legion/extensions/llm/openai/transport/messages/registry_event'
-            message_class_defined?
-          rescue LoadError => e
-            if respond_to?(:handle_exception)
-              handle_exception(e, level: :debug, handled: true,
-                                  operation: 'transport_message_available?')
-            end
-            false
-          end
-
-          def message_class_defined?
-            defined?(::Legion::Extensions::Llm::Openai::Transport::Messages::RegistryEvent)
-          end
-
-          def message_class
-            ::Legion::Extensions::Llm::Openai::Transport::Messages::RegistryEvent
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/openai/transport/exchanges/llm_registry.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Openai
-        module Transport
-          module Exchanges
-            # Topic exchange for OpenAI provider availability events.
-            class LlmRegistry < ::Legion::Transport::Exchange
-              def exchange_name
-                'llm.registry'
-              end
-
-              def default_type
-                'topic'
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/openai/transport/messages/registry_event.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/extensions/llm/openai/transport/exchanges/llm_registry'
-
-module Legion
-  module Extensions
-    module Llm
-      module Openai
-        module Transport
-          module Messages
-            # Publishes lex-llm RegistryEvent envelopes to the llm.registry exchange.
-            class RegistryEvent < ::Legion::Transport::Message
-              def initialize(event:, **options)
-                super(**event.to_h.merge(options))
-              end
-
-              def exchange
-                Transport::Exchanges::LlmRegistry
-              end
-
-              def routing_key
-                @options[:routing_key] || "llm.registry.#{@options.fetch(:event_type)}"
-              end
-
-              def type
-                'llm.registry.event'
-              end
-
-              def app_id
-                @options[:app_id] || RegistryPublisher::APP_ID
-              end
-
-              def persistent # rubocop:disable Naming/PredicateMethod
-                false
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end