lex-llm-anthropic 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e95d99f4330626d49048eb320631d65206496fd54c14bfb83fb2fa5cae638735
-  data.tar.gz: b7127571b56508f8c5bf3b1f68220368b8a674fa0caff76094d9ef932b6b51a7
+  metadata.gz: a17bd5b25cc4b70aa861ad36f5c700dc96558efde25b11dc9a362ac7d545450e
+  data.tar.gz: 7f02f82b866d53792ca985c45cc36672d025722922fa853c8ac36948ed9514d1
 SHA512:
-  metadata.gz: f39817dc0618493345d1ca7935f84388d97ae87a152994f895ceb8729eb8cde2e4a45ac0c34070fe62dc7243b8b51f1910f0a44ce5bf3b67fdae0ae3c1fa993a
-  data.tar.gz: 30b3e0705c65e392f5c5df2881ea9c17e3abea10e96001a7c95f2a9eb4b76cd8cde5cd7845313a85f6c30ff0dc69ce9ac73fca664277ec668116a07510c31a4a
+  metadata.gz: b2b0860a1bb74cf8498f748aff5d709783591c8334c3f8ecfa52fd09fe6c29d84b0b74c2863fb64b76a3465520259ca26497b368e9db5cb6330a79f46a2a004c
+  data.tar.gz: 57800905a3e9e3faf9dd34e964b01c3b66a0eda08d86d7e2e4d3a7357d46a41164ab6740d5b5f532b505e7c150749cfe59fef411dffa2a4d0b3aeffb97644623

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.2.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.1.5 - 2026-04-28
+
+- Publish best-effort `llm.registry` discovered-model availability events when transport is already loaded.
+
 ## 0.1.4 - 2026-04-28
 
 - Require current shared Legion JSON, logging, settings, and LLM extension gems.

data/lex-llm-anthropic.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/anthropic/provider.rb

@@ -9,10 +9,16 @@ module Legion
         # Anthropic Messages API provider implementation for the Legion::Extensions::Llm contract.
         class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
           class << self
+            attr_writer :registry_publisher
+
             def slug = 'anthropic'
             def configuration_options = %i[anthropic_api_key anthropic_api_base anthropic_version]
             def configuration_requirements = %i[anthropic_api_key]
             def capabilities = Capabilities
+
+            def registry_publisher
+              @registry_publisher ||= RegistryPublisher.new
+            end
           end
 
           # Capability predicates for Anthropic chat model offerings.
@@ -45,6 +51,12 @@ module Legion
             raise NotImplementedError, 'Anthropic does not expose embeddings through this provider'
           end
 
+          def list_models
+            super.tap do |models|
+              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
+            end
+          end
+
           private
 
           def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:) # rubocop:disable Metrics/ParameterLists
@@ -339,8 +351,7 @@ module Legion
                 id: model_id,
                 name: model['display_name'] || model_id,
                 provider: provider,
-                created_at: model['created_at'],
-                metadata: model
+                metadata: model.merge('created_at' => model['created_at']).compact
               )
             end
           end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Anthropic
+        # Builds sanitized lex-llm registry envelopes for Anthropic provider state.
+        class RegistryEventBuilder
+          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: :anthropic,
+              provider_instance: provider_instance,
+              transport: :http,
+              model: model.id,
+              usage_type: :inference,
+              capabilities: Array(model.capabilities).map(&:to_sym),
+              limits: model_limits(model),
+              metadata: { lex: :llm_anthropic, 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_anthropic, provider: :anthropic, 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 provider_instance
+            configured_node = (::Legion::Settings.dig(:node, :canonical_name) if defined?(::Legion::Settings))
+            value = configured_node.to_s.strip
+            value.empty? ? :anthropic : value.to_sym
+          rescue StandardError
+            :anthropic
+          end
+
+          def registry_event_class
+            ::Legion::Extensions::Llm::Routing::RegistryEvent
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Anthropic
+        # Best-effort publisher for Anthropic provider availability events.
+        class RegistryPublisher
+          APP_ID = 'lex-llm-anthropic'
+
+          def initialize(builder: RegistryEventBuilder.new)
+            @builder = builder
+          end
+
+          def publish_models_async(models, readiness:)
+            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
+              log_publish_failure(e, level: :debug)
+            end
+          rescue StandardError => e
+            log_publish_failure(e, level: :debug)
+            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
+            log_publish_failure(e)
+            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
+            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/anthropic/transport/messages/registry_event'
+            message_class_defined?
+          rescue LoadError
+            false
+          end
+
+          def message_class_defined?
+            defined?(::Legion::Extensions::Llm::Anthropic::Transport::Messages::RegistryEvent)
+          end
+
+          def message_class
+            ::Legion::Extensions::Llm::Anthropic::Transport::Messages::RegistryEvent
+          end
+
+          def log_publish_failure(error, level: :warn)
+            message = "[lex-llm-anthropic] llm.registry publish failed: #{error.class}: #{error.message}"
+            logger = ::Legion::Extensions::Llm.logger if defined?(::Legion::Extensions::Llm)
+            if logger.respond_to?(level)
+              logger.public_send(level, message)
+            elsif logger.respond_to?(:debug)
+              logger.debug(message)
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Anthropic
+        module Transport
+          module Exchanges
+            # Topic exchange for Anthropic 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/anthropic/transport/messages/registry_event.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/anthropic/transport/exchanges/llm_registry'
+
+module Legion
+  module Extensions
+    module Llm
+      module Anthropic
+        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

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Anthropic
-        VERSION = '0.1.4'
+        VERSION = '0.2.0'
       end
     end
   end

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/llm'
+require 'legion/extensions/llm/anthropic/registry_event_builder'
+require 'legion/extensions/llm/anthropic/registry_publisher'
 require 'legion/extensions/llm/anthropic/provider'
 require 'legion/extensions/llm/anthropic/version'
 
@@ -10,6 +12,7 @@ module Legion
       # Anthropic provider extension namespace.
       module Anthropic
         extend ::Legion::Extensions::Core if ::Legion::Extensions.const_defined?(:Core, false)
+        extend Legion::Extensions::Llm::AutoRegistration
 
         PROVIDER_FAMILY = :anthropic
 
@@ -30,10 +33,64 @@ module Legion
         def self.provider_class
           Provider
         end
+
+        def self.discover_instances # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+          candidates = {}
+
+          env_key = CredentialSources.env('ANTHROPIC_API_KEY')
+          if env_key
+            candidates[:env] = {
+              api_key: env_key,
+              anthropic_api_key: env_key,
+              tier: :frontier
+            }
+          end
+
+          claude_key = CredentialSources.claude_config_value(:anthropicApiKey)
+          if claude_key
+            candidates[:claude] = {
+              api_key: claude_key,
+              anthropic_api_key: claude_key,
+              tier: :frontier
+            }
+          end
+
+          settings_config = CredentialSources.setting(:extensions, :llm, :anthropic)
+          if settings_config.is_a?(Hash)
+            settings_key = settings_config[:api_key] || settings_config['api_key']
+            if settings_key
+              candidates[:settings] = settings_config.merge(
+                anthropic_api_key: settings_key,
+                tier: :frontier
+              )
+            end
+          end
+
+          if defined?(Legion::Identity::Broker)
+            broker_cred = Legion::Identity::Broker.credential_for(:anthropic)
+            if broker_cred
+              candidates[:broker] = {
+                api_key: broker_cred,
+                anthropic_api_key: broker_cred,
+                tier: :frontier
+              }
+            end
+          end
+
+          CredentialSources.dedup_credentials(candidates)
+        end
+
+        def self.register_discovered_instances
+          super
+          return unless defined?(Legion::LLM::Call::Registry)
+
+          Legion::LLM::Call::Registry.instances_for(:anthropic).each do |instance_id, adapter|
+            Legion::LLM::Call::Registry.register(:claude, adapter, instance: instance_id)
+          end
+        end
       end
     end
   end
 end
 
-Legion::Extensions::Llm::Provider.register(Legion::Extensions::Llm::Anthropic::PROVIDER_FAMILY,
-                                           Legion::Extensions::Llm::Anthropic::Provider)
+Legion::Extensions::Llm::Anthropic.register_discovered_instances

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-anthropic
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.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: Anthropic provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -84,6 +84,10 @@ files:
 - lex-llm-anthropic.gemspec
 - lib/legion/extensions/llm/anthropic.rb
 - lib/legion/extensions/llm/anthropic/provider.rb
+- lib/legion/extensions/llm/anthropic/registry_event_builder.rb
+- lib/legion/extensions/llm/anthropic/registry_publisher.rb
+- lib/legion/extensions/llm/anthropic/transport/exchanges/llm_registry.rb
+- lib/legion/extensions/llm/anthropic/transport/messages/registry_event.rb
 - lib/legion/extensions/llm/anthropic/version.rb
 homepage: https://github.com/LegionIO/lex-llm-anthropic
 licenses: