lex-llm-openai 0.3.0 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cd48c5acd857910771717afe92892f537270d62a6f6d24d0f71e2b5805abb9d
-  data.tar.gz: c8f1a0644cb7cf1fe993f6d17b5aba3167e56d8f44f04fe0e0d6afe8d70a7146
+  metadata.gz: 8cc102a70c5d99414bb836b6b9204a1c031a9f98072b5430e824b2ae944cd44a
+  data.tar.gz: 0d6cd458a0812c8767bef92785026a17ae1fa465aecd84801cbca27070570706
 SHA512:
-  metadata.gz: 2f5a9d6f495bb5fac304ef891d5f2f93353ff0d6909c54c506a448030e67791f7b79fbffb546e8b7cf94b5d8d8eef1f4b8122bd5df7115e47ff537baa33e8483
-  data.tar.gz: 7f40adfce35ab368b2db2d82a603fe48f2de269e13a093cab8adc15a946b80e2d02792fd97cf400895f55a18529f140d630e7dd4264d1f0799aa3328dd71908d
+  metadata.gz: db59247eafd9bd082806e464602315660dd7b3d1871c894acc85dae76db7ad9f5a58a94284c3b47b2fd5cc923dee9e76101f9c1df064bb18718d474999fa0d28
+  data.tar.gz: 35f02198724ba77c8b2a329c11c5aa9fe0d106d2a93a140f0a7d88041246d6c01c09d9a23a354d844638041744526280b671c186770c77ab3f2ccae7dc5d9950

data/.github/workflows/ci.yml

@@ -8,8 +8,20 @@ jobs:
   ci:
     uses: LegionIO/.github/.github/workflows/ci.yml@main
 
+  excluded-files:
+    uses: LegionIO/.github/.github/workflows/excluded-files.yml@main
+
+  security:
+    uses: LegionIO/.github/.github/workflows/security-scan.yml@main
+
+  version-changelog:
+    uses: LegionIO/.github/.github/workflows/version-changelog.yml@main
+
+  dependency-review:
+    uses: LegionIO/.github/.github/workflows/dependency-review.yml@main
+
   release:
-    needs: ci
+    needs: [ci, excluded-files, security]
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     uses: LegionIO/.github/.github/workflows/release.yml@main
     secrets:

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 0.3.6 - 2026-05-06
+
+- Load provider-owned fleet actors through the LegionIO subscription base and the canonical OpenAI provider root.
+- Keep fleet runners anchored on the provider root namespace so provider constants and instance discovery are always loaded.
+- Strip temporary generic API key, organization, and project fields from discovered OpenAI instance configs after credential deduplication.
+- Gate release publishing on the shared security workflow.
+
+## 0.3.5 - 2026-05-06
+
+- Advertise OpenAI moderation and audio usage in the default provider instance settings.
+- Refresh README architecture and verification guidance for the shared `lex-llm` registry and fleet responder boundary.
+
+## 0.3.4 - 2026-05-06
+
+- Use the shared `lex-llm` fleet provider responder helper for provider-owned fleet workers.
+- Remove the runtime `legion-llm` dependency and require `lex-llm >= 0.4.3` for responder-side fleet execution.
+
+## 0.3.3 - 2026-05-06
+
+- Remove require-time provider self-registration; `legion-llm` now owns adapter creation and registry writes from loaded provider discovery metadata.
+- Bump dependency floors to `lex-llm >= 0.4.1` and `legion-llm >= 0.9.1`.
+
+## 0.3.2 - 2026-05-06
+
+- Add provider contract specs for the shared keyword-only `lex-llm` provider API.
+- Move OpenAI defaults back to `Legion::Extensions::Llm.provider_settings` with credentials and instance-level fleet responder settings.
+- Remove `gateways` discovery; OpenAI-compatible targets are now named provider instances.
+- Add provider-owned fleet responder actor and runner backed by `legion-llm` fleet policy execution.
+- Bump the transport dependency floor to `legion-transport >= 1.4.14`.
+
+## 0.3.1 - 2026-05-03
+
+- Normalize generic settings keys to OpenAI provider config keys during extension and gateway instance discovery.
+
 ## 0.3.0 - 2026-05-01
 
 - Add auto-discovery via CredentialSources and AutoRegistration from lex-llm 0.3.0

data/Gemfile

@@ -4,6 +4,8 @@ source 'https://rubygems.org'
 
 group :test do
   llm_base_path = ENV.fetch('LEX_LLM_PATH', File.expand_path('../lex-llm', __dir__))
+  transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
+  gem 'legion-transport', path: transport_path if File.directory?(transport_path)
   gem 'lex-llm', path: llm_base_path if File.directory?(llm_base_path)
 end
 

data/README.md

@@ -2,13 +2,13 @@
 
 LegionIO LLM provider extension for OpenAI.
 
-This gem lives under `Legion::Extensions::Llm::Openai` and depends on `lex-llm` for shared provider-neutral routing, fleet, and schema primitives.
+This gem lives under `Legion::Extensions::Llm::Openai` and depends on `lex-llm >= 0.4.3` for shared provider-neutral routing, response normalization, fleet envelopes, fleet responder execution, and schema primitives.
 
 Load it with `require 'legion/extensions/llm/openai'`.
 
 ## What It Provides
 
-- `Legion::Extensions::Llm::Provider` registration as `:openai`
+- OpenAI provider discovery under the `:openai` provider family
 - Chat completions via `POST /v1/chat/completions`
 - Streaming chat completions (same endpoint, `stream: true`)
 - Model discovery via `GET /v1/models`
@@ -24,28 +24,30 @@ Load it with `require 'legion/extensions/llm/openai'`.
 - Normalized chat, embedding, moderation, image, and audio capability mapping for discovered models
 - Shared fleet/default settings via `Legion::Extensions::Llm.provider_settings`
 - Best-effort `llm.registry` availability event publishing for discovered models
+- Provider-owned fleet request handling through `Legion::Extensions::Llm::Fleet::ProviderResponder`
 
 ## Architecture
 
 ```
 Legion::Extensions::Llm::Openai
-├── Provider                              # OpenAI provider implementation (chat, models, embeddings, etc.)
-│   └── Capabilities                      # Model family capability predicates
-├── RegistryPublisher                     # Async llm.registry event publisher
-├── RegistryEventBuilder                  # Sanitized registry event envelope builder
-└── Transport
-    ├── Exchanges::LlmRegistry            # Topic exchange for llm.registry
-    └── Messages::RegistryEvent           # AMQP message for registry events
+|-- Provider                              # OpenAI provider implementation (chat, models, embeddings, etc.)
+|   `-- Capabilities                      # Model family capability predicates
+|-- Actor::FleetWorker                    # Subscription actor gate for provider-owned fleet requests
+`-- Runners::FleetWorker                  # Delegates request execution to lex-llm ProviderResponder
 ```
 
+Registry publishing, event envelope construction, fleet protocol handling, and fleet response/error transport live in `lex-llm`. This provider intentionally does not depend on `legion-llm` at runtime.
+
 ## Observability
 
-All classes include `Legion::Logging::Helper` (when available) providing:
+The provider and root extension namespace use `Legion::Logging::Helper` for:
 
 - Structured `handle_exception` calls on every rescue block
-- Info-level action logging for provider registration, model listing, model retrieval, and registry publishing
+- Info-level action logging for model listing, model retrieval, and registry publishing
 - Automatic log segment derivation and component type tagging
 
+Fleet actor and runner code stays thin and delegates execution, ack/reject handling, and response publication to the shared `lex-llm` responder helper.
+
 ## Defaults
 
 ```ruby
@@ -85,18 +87,38 @@ end
 
 | Gem | Purpose |
 |-----|---------|
-| `lex-llm` (>= 0.1.5) | Shared provider contract, fleet settings, routing |
+| `lex-llm` (>= 0.4.3) | Shared provider contract, response normalization, fleet settings, routing, and fleet responder execution |
+| `legion-transport` (>= 1.4.14) | AMQP subscriptions and replies |
 | `legion-json` (>= 1.2.1) | JSON serialization |
 | `legion-logging` (>= 1.3.2) | Structured logging via Helper |
 | `legion-settings` (>= 1.3.14) | Configuration management |
 
+## Fleet Responder
+
+Provider instances can opt in to consuming Legion LLM fleet requests. The provider-owned fleet actor only starts when at least one configured instance enables `respond_to_requests`, and the runner delegates execution to `Legion::Extensions::Llm::Fleet::ProviderResponder` from `lex-llm`.
+
+```yaml
+extensions:
+  llm:
+    openai:
+      instances:
+        local:
+          fleet:
+            enabled: true
+            respond_to_requests: true
+            capabilities:
+              - chat
+              - stream_chat
+              - embed
+              - image
+```
+
 ## Development
 
 ```bash
 bundle install
-bundle exec rspec --format progress   # all pass
-bundle exec rubocop -A                # auto-fix
-bundle exec rubocop                   # lint check (0 offenses)
+bundle exec rspec --format json --out tmp/rspec_results.json --format progress --out tmp/rspec_progress.txt
+bundle exec rubocop -A
 ```
 
 ## License

data/lex-llm-openai.gemspec

@@ -26,5 +26,6 @@ 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.3.0'
+  spec.add_dependency 'legion-transport', '>= 1.4.14'
+  spec.add_dependency 'lex-llm', '>= 0.4.3'
 end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+begin
+  require 'legion/extensions/actors/subscription'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
+unless defined?(Legion::Extensions::Actors::Subscription)
+  raise LoadError, 'LegionIO actor runtime is required for OpenAI fleet worker'
+end
+
+require 'legion/extensions/llm/openai'
+require 'legion/extensions/llm/fleet/provider_responder'
+
+module Legion
+  module Extensions
+    module Llm
+      module Openai
+        module Actor
+          # Subscription actor for OpenAI fleet request consumption.
+          class FleetWorker < Legion::Extensions::Actors::Subscription
+            def runner_class
+              'Legion::Extensions::Llm::Openai::Runners::FleetWorker'
+            end
+
+            def runner_function
+              'handle_fleet_request'
+            end
+
+            def use_runner?
+              false
+            end
+
+            def enabled?
+              Legion::Extensions::Llm::Fleet::ProviderResponder.enabled_for?(Openai.discover_instances)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -244,10 +244,3 @@ 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/runners/fleet_worker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/fleet/provider_responder'
+require 'legion/extensions/llm/openai'
+
+module Legion
+  module Extensions
+    module Llm
+      module Openai
+        module Runners
+          # Runner entrypoint for OpenAI fleet request execution.
+          module FleetWorker
+            module_function
+
+            def handle_fleet_request(payload, delivery: nil, properties: nil)
+              Legion::Extensions::Llm::Fleet::ProviderResponder.call(
+                payload: payload,
+                provider_family: Openai::PROVIDER_FAMILY,
+                provider_class: Openai::Provider,
+                provider_instances: -> { Openai.discover_instances },
+                delivery: delivery,
+                properties: properties
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -16,18 +16,36 @@ module Legion
         PROVIDER_FAMILY = :openai
 
         def self.default_settings
-          {
-            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: {}
-          }
+          ::Legion::Extensions::Llm.provider_settings(
+            family: PROVIDER_FAMILY,
+            instance: {
+              endpoint: 'https://api.openai.com',
+              default_model: 'gpt-4o',
+              tier: :frontier,
+              transport: :http,
+              credentials: {
+                api_key: 'env://OPENAI_API_KEY',
+                organization_id: nil,
+                project_id: nil
+              },
+              usage: {
+                inference: true,
+                embedding: true,
+                moderation: true,
+                image: true,
+                audio: true
+              },
+              limits: { concurrency: 4 },
+              fleet: {
+                enabled: false,
+                respond_to_requests: false,
+                capabilities: %i[chat stream_chat embed image],
+                lanes: [],
+                concurrency: 4,
+                queue_suffix: nil
+              }
+            }
+          )
         end
 
         def self.provider_class
@@ -39,52 +57,78 @@ module Legion
 
           # 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
+          candidates[:env] = { api_key: env_key, 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
+          if codex_env_key
+            candidates[:codex_env] = { api_key: codex_env_key, openai_api_key: codex_env_key, tier: :frontier }
+          end
 
           # 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
+          candidates[:codex] = { api_key: codex_tok, 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
+          candidates[:codex_key] = { api_key: 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
+          candidates[:claude] = { api_key: claude_key, 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(
+              candidates[:settings] = normalize_instance_config(settings_config).merge(
+                api_key: settings_key,
                 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)
+          # 7. Named provider instances from extension settings
+          settings_instances(settings_config).each do |name, config|
+            next unless config.is_a?(Hash)
 
-              candidates[name.to_sym] = config.merge(tier: :openai_compat)
-            end
+            normalized = normalize_instance_config(config)
+            dedup_key = normalized[:openai_api_key]
+            normalized[:api_key] = dedup_key if dedup_key
+            candidates[name.to_sym] = normalized.merge(tier: :frontier)
           end
 
           # 8. Dedup
-          CredentialSources.dedup_credentials(candidates)
+          CredentialSources.dedup_credentials(candidates).transform_values { |config| sanitize_instance_config(config) }
+        end
+
+        def self.settings_instances(config)
+          return {} unless config.is_a?(Hash)
+
+          instances = config[:instances] || config['instances']
+          instances.is_a?(Hash) ? instances : {}
         end
+
+        def self.normalize_instance_config(config) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          normalized = config.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+          normalized[:openai_api_key] ||= normalized.delete(:api_key)
+          normalized[:openai_api_base] ||= normalized.delete(:base_url)
+          normalized[:openai_api_base] ||= normalized.delete(:api_base)
+          normalized[:openai_api_base] ||= normalized.delete(:endpoint)
+          normalized[:openai_organization_id] ||= normalized.delete(:organization_id)
+          normalized[:openai_project_id] ||= normalized.delete(:project_id)
+          normalized.compact.except(:instances)
+        end
+
+        def self.sanitize_instance_config(config)
+          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)
       end
     end
   end
 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.3.0
+  version: 0.3.6
 platform: ruby
 authors:
 - LegionIO
@@ -51,20 +51,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.14
 - !ruby/object:Gem::Dependency
   name: lex-llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.3
 description: OpenAI provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -83,7 +97,9 @@ files:
 - README.md
 - lex-llm-openai.gemspec
 - lib/legion/extensions/llm/openai.rb
+- lib/legion/extensions/llm/openai/actors/fleet_worker.rb
 - lib/legion/extensions/llm/openai/provider.rb
+- lib/legion/extensions/llm/openai/runners/fleet_worker.rb
 - lib/legion/extensions/llm/openai/version.rb
 homepage: https://github.com/LegionIO/lex-llm-openai
 licenses: