lex-llm-anthropic 0.2.20 → 0.2.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8d65710f4980c8851f9ff9457cadb0053493ec4817e91b0b046ea354297c9a2
-  data.tar.gz: d88fda72706b4035cd5ba2866c3b4354c2f36bdcad1d56bd1373684a8c82b0f9
+  metadata.gz: a43ec4b5821302a3e7a3144ee23d22bb4954530af9cebd7c5b51b6767915b575
+  data.tar.gz: 3a470f8f0a6b69a96411eb1c13276eee6428e90e176d93a42e64fb442ce4da02
 SHA512:
-  metadata.gz: 8a81ea1ad5a04c67d4079af690238308be289c66315f19555a4d5423a92c43f3ffc940356bf52791d6fd504a446e5fc53fc495c798458f42a7e18bc6beaa5863
-  data.tar.gz: d53359d7292d05f5719a7412b90d6a8761cc2982f8325a63446dc92ded3c77957c2914a1138eda5eaf52ff56e41408aeea3337cb49c62a00506de860780ad89f
+  metadata.gz: 5c80ed046d1c0b7d9ad03be2ad3f06284732d5cb53419cc45bdf6c8ccbc3f53162c6e5831c6e42cc322435285dcd24693c4abc955c626995fbccb329b57e92f6
+  data.tar.gz: 975f2fde3051df569513aed373a8485559b240f7c0a548759c4fd6ec9d9b363c74f9c1788a43e33a102b6f7a73e60fb0f6d7f728d5d267ae4096a9aef72c493d

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.2.26] - 2026-06-20
+
+### Fixed
+- Stub shared registry publishing through `RegistryPublisher#schedule` in specs so async availability-event coverage stays stable after the shared publisher moved off raw `Thread.new`.
+
+## [0.2.25] - 2026-06-20
+
+### Fixed
+- Stop bulk-publishing Anthropic model availability from `list_models`; discovery now emits one registry event per seen model from the shared `lex-llm` policy-filter path so blocked models stay observable without duplicate publishes.
+
+## [0.2.24] - 2026-06-20
+
+### Fixed
+- Route Anthropic capability overrides through the shared `lex-llm` provider contract so provider, instance, and model settings all resolve through the same canonical capability vocabulary.
+
+## [0.2.23] - 2026-06-19
+
+### Changed
+- Adopt `Legion::Extensions::Llm::Inventory::ScopedRefresher` mixin (lex-llm 0.6.0). Discovery
+  refresh actors now write directly to the live `Inventory` catalog via `Inventory.write_lane`.
+- Pin `lex-llm >= 0.6.0` and `legion-llm >= 0.14.0` in gemspec.
+- Standard `weight: 100` default added to provider instance settings schema.
+
+## 0.2.21 - 2026-06-17
+
+### Changed
+- **Policy-aware default model** — `default_model` is no longer a hardcoded literal forced via `||=`. The `claude-sonnet-4-6` 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. (Fixes the case where a haiku-only whitelist still surfaced a sonnet default.) Requires lex-llm >= 0.5.4.
+
 ## 0.2.20 - 2026-06-16
 
 - dependency updates, code quality improvements

data/lex-llm-anthropic.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.6.0'
 end

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

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 begin
   require 'legion/extensions/actors/every'
 rescue LoadError => e
   warn(e.message) if $VERBOSE
 end
 
+begin
+  require 'legion/extensions/llm/inventory/scoped_refresher'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
 return unless defined?(Legion::Extensions::Actors::Every)
 
 module Legion
@@ -15,8 +23,11 @@ module Legion
         module Actor
           class DiscoveryRefresh < Legion::Extensions::Actors::Every
             include Legion::Logging::Helper
+            include Legion::Extensions::Llm::Inventory::ScopedRefresher if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
 
-            REFRESH_INTERVAL = 1800
+            EMBED_TYPES = %i[embed embedding].freeze
+
+            def self.every_seconds = 3600
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -26,22 +37,125 @@ module Legion
             def generate_task?  = false
 
             def time
-              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+              return self.class.every_seconds unless defined?(Legion::Settings)
 
-              Legion::Settings.dig(:extensions, :llm, :anthropic, :discovery_interval) || REFRESH_INTERVAL
+              Legion::Settings.dig(:extensions, :llm, :anthropic, :discovery_interval) || self.class.every_seconds
             end
 
-            def manual
-              log.debug('[anthropic][discovery_refresh] refreshing model list')
-              return unless defined?(Legion::LLM::Discovery)
+            def scope_key
+              { provider: :anthropic }
+            end
+
+            def compute_lanes_for_scope
+              return [] unless defined?(Legion::LLM::Call::Registry)
+
+              instances = Legion::LLM::Call::Registry.all_instances.select do |e|
+                (e[:provider] || '').to_sym == :anthropic
+              end
+
+              lanes = []
+
+              instances.each do |instance|
+                adapter = instance[:adapter]
+                source =
+                  if adapter.respond_to?(:discover_offerings) then adapter.discover_offerings(live: true)
+                  elsif adapter.respond_to?(:offerings) then adapter.offerings(live: false)
+                  else next
+                  end
+
+                Array(source).filter_map do |raw|
+                  offering = offering_to_hash(raw)
+                  next unless offering
+
+                  instance_id = instance[:instance] || instance[:instance_id] || instance[:id] || 'default'
+                  model       = offering[:model] || offering[:id]
+                  next unless model
+
+                  offering_type = if EMBED_TYPES.include?((offering[:type] || '').to_sym)
+                                    :embedding
+                                  else
+                                    :inference
+                                  end
 
-              Legion::LLM::Discovery.refresh_discovered_models!(provider: :anthropic)
+                  tier = offering[:tier]&.to_sym || :frontier
 
-              Legion::LLM::Router.populate_auto_rules(Legion::LLM::Discovery.discovered_instances) if defined?(Legion::LLM::Router) && Legion::LLM::Router.respond_to?(:populate_auto_rules)
-              Legion::LLM::Inventory.invalidate_offerings_cache! if defined?(Legion::LLM::Inventory) && Legion::LLM::Inventory.respond_to?(:invalidate_offerings_cache!)
+                  capabilities = if defined?(Legion::Extensions::Llm::Inventory::Capabilities)
+                                   Legion::Extensions::Llm::Inventory::Capabilities.normalize(offering[:capabilities])
+                                 else
+                                   Array(offering[:capabilities])
+                                 end
+
+                  lane_id = Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(
+                    tier:            tier,
+                    provider_family: :anthropic,
+                    instance_id:     instance_id,
+                    type:            offering_type,
+                    model:           model
+                  )
+
+                  lane = {
+                    id:                    lane_id,
+                    tier:                  tier,
+                    provider_family:       :anthropic,
+                    instance_id:           instance_id,
+                    model:                 model,
+                    canonical_model_alias: offering[:canonical_model_alias],
+                    type:                  offering_type,
+                    capabilities:          capabilities,
+                    limits:                offering[:limits] || {},
+                    enabled:               offering.fetch(:enabled, true),
+                    cost:                  offering[:cost] || {}
+                  }.compact
+
+                  lanes << lane
+
+                  # G29: also emit a fleet lane for each inference lane when fleet dispatch is configured
+                  if offering_type == :inference
+                    settings = Legion::Settings.dig(:extensions, :llm, :anthropic) || {}
+                    if settings[:fleet]&.dig(:dispatch, :enabled)
+                      fleet_id = Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(
+                        tier:            :fleet,
+                        provider_family: :anthropic,
+                        instance_id:     instance_id,
+                        type:            :inference,
+                        model:           model
+                      )
+                      lanes << lane.merge(id: fleet_id, tier: :fleet)
+                    end
+                  end
+                end
+              end
+
+              lanes
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'anthropic.actor.discovery_refresh.compute_lanes')
+              []
+            end
+
+            def credential_hash
+              settings = Legion::Settings.dig(:extensions, :llm, :anthropic) || {}
+              Digest::SHA256.hexdigest(settings[:api_key].to_s + settings[:instances].to_s)[0, 16]
+            end
+
+            def manual
+              tick if respond_to?(:tick)
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'anthropic.actor.discovery_refresh')
             end
+
+            private
+
+            # ModelOffering objects do not implement `[]`; normalize to a Hash so the
+            # writer stays Hash-shaped. Hash inputs pass through untouched.
+            def offering_to_hash(offering)
+              return nil if offering.nil?
+              return offering if offering.is_a?(Hash)
+
+              hash = offering.to_h
+              hash[:type] ||= hash[:usage_type]
+              hash[:enabled] = offering.respond_to?(:enabled?) ? offering.enabled? : true
+              hash
+            end
           end
         end
       end

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

@@ -65,11 +65,32 @@ module Legion
           def list_models(**)
             log.debug { 'listing available Anthropic models' }
             super.tap do |models|
-              log.debug { "discovered #{Array(models).size} Anthropic model(s); publishing to registry" }
-              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
+              log.debug { "discovered #{Array(models).size} Anthropic model(s)" }
             end
           end
 
+          def discover_offerings(live: false, raise_on_unreachable: false, **filters)
+            return filter_cached_offerings(Array(@cached_offerings), filters) unless live
+
+            provider_health = health(live:)
+            readiness = discovery_registry_readiness(provider_health, live:)
+            @cached_offerings = Array(list_models(live:, **filters)).filter_map do |model|
+              self.class.registry_publisher.publish_models_async([model], readiness:)
+              next unless model_matches_filters?(model, filters)
+              next unless model_allowed?(model.id)
+
+              log.debug("[#{slug}] instance=#{provider_instance_id} action=model_discovered model=#{model.id} family=#{model.family}")
+              offering_from_model(model, health: provider_health)
+            end
+            log.info("[#{slug}] instance=#{provider_instance_id} action=discover_complete model_count=#{Array(@cached_offerings).size}")
+            @cached_offerings
+          rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+            log.warn("[#{slug}] instance=#{provider_instance_id} unreachable: #{e.message}")
+            raise if raise_on_unreachable
+
+            []
+          end
+
           CONTEXT_WINDOWS = {
             'claude-opus-4'   => 200_000,
             'claude-sonnet-4' => 200_000,
@@ -84,6 +105,16 @@ module Legion
 
           private
 
+          def discovery_registry_readiness(provider_health, live:)
+            {
+              provider:   slug.to_sym,
+              configured: configured?,
+              ready:      provider_health[:ready] == true,
+              live:       live,
+              health:     provider_health
+            }
+          end
+
           def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:)
             log_render_payload(messages:, tools:, model:, stream:, schema:)
             system_messages, chat_messages = messages.partition { |message| message.role == :system }
@@ -420,30 +451,17 @@ module Legion
           end
 
           def resolve_model_capabilities(model_id)
-            provider_settings = CredentialSources.setting(:extensions, :llm, :anthropic)
-            provider_cfg = provider_settings.is_a?(Hash) ? provider_settings.except(:instances) : {}
-            model_cfg = model_config_for(model_id, provider_settings)
-
             Legion::Extensions::Llm::CapabilityPolicy.resolve(
               real:              {},
               provider_catalog:  {},
               probe:             {},
               provider_envelope: { streaming: true, tools: true },
-              provider_config:   provider_cfg,
-              instance_config:   config.respond_to?(:to_h) ? config.to_h : {},
-              model_config:      model_cfg
+              provider_config:   provider_capability_config,
+              instance_config:   instance_capability_config,
+              model_config:      model_capability_config(model_id)
             )
           end
 
-          def model_config_for(model_id, provider_settings)
-            return {} unless provider_settings.is_a?(Hash)
-
-            models = provider_settings[:models] || provider_settings['models']
-            return {} unless models.is_a?(Hash)
-
-            models[model_id.to_sym] || models[model_id] || {}
-          end
-
           def infer_context_window(model_id)
             CONTEXT_WINDOWS.find { |prefix, _| model_id.start_with?(prefix) }&.last
           end

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

@@ -59,7 +59,7 @@ module Legion
             value = configured_node.to_s.strip
             value.empty? ? :anthropic : value.to_sym
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true,
+            handle_exception(e, level: :warn, handled: true,
                                 operation: 'anthropic.registry.provider_instance')
             :anthropic
           end

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

@@ -48,6 +48,7 @@ module Legion
                            else
                              render_system_content(system_messages)
                            end
+            inject_prompt_cache_control!(system_parts, canonical_request.system)
             message_parts = render_messages(chat_messages, thinking: thinking_enabled?(canonical_request))
             tools = render_tools(canonical_request.tools)
             tool_choice = render_tool_choice(canonical_request.tool_choice)
@@ -172,7 +173,7 @@ module Legion
               nil
             end
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'anthropic.translator.parse_chunk')
+            handle_exception(e, level: :warn, handled: true, operation: 'anthropic.translator.parse_chunk')
             Canonical::Chunk.error_chunk(
               error:      "#{e.class}: #{e.message}",
               request_id: raw[:request_id] || ''
@@ -639,6 +640,31 @@ module Legion
             :end_turn
           end
 
+          # --- prompt caching ---
+
+          def inject_prompt_cache_control!(system_parts, raw_system)
+            return unless system_parts.is_a?(Array) && !system_parts.empty?
+            return unless raw_system.is_a?(String)
+
+            caching = prompt_caching_settings
+            return unless caching[:enabled] != false
+
+            min_tokens = caching[:min_tokens] || 1024
+            return unless raw_system.length > min_tokens
+
+            last = system_parts.last
+            return unless last.is_a?(Hash) && last[:type] == 'text'
+
+            last[:cache_control] = { type: 'ephemeral' }
+            log.debug "[llm][anthropic][translator] action=inject_cache_control length=#{raw_system.length}"
+          end
+
+          def prompt_caching_settings
+            return @config[:prompt_caching] if @config.key?(:prompt_caching)
+
+            Legion::Settings.dig(:extensions, :llm, :anthropic, :prompt_caching) || {}
+          end
+
           # --- settings helpers ---
 
           def settings_default_max_tokens

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Anthropic
-        VERSION = '0.2.20'
+        VERSION = '0.2.26'
       end
     end
   end

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

@@ -17,12 +17,16 @@ module Legion
         extend Legion::Extensions::Llm::AutoRegistration
 
         PROVIDER_FAMILY = :anthropic
+        # 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 = 'claude-sonnet-4-6'
 
         def self.default_settings
           ::Legion::Extensions::Llm.provider_settings(
             family:   PROVIDER_FAMILY,
             instance: {
-              default_model:      'claude-sonnet-4-6',
+              default_model:      DEFAULT_MODEL,
               endpoint:           'https://api.anthropic.com',
               api_version:        '2023-10-16',
               default_max_tokens: 4096,
@@ -31,6 +35,7 @@ module Legion
               credentials:        { api_key: 'env://ANTHROPIC_API_KEY' },
               usage:              { inference: true, embedding: false, image: false },
               limits:             { concurrency: 4 },
+              prompt_caching:     {},
               fleet:              {
                 enabled:             false,
                 respond_to_requests: false,
@@ -117,11 +122,20 @@ module Legion
           CredentialSources.dedup_credentials(candidates).transform_values do |config|
             sanitized = sanitize_instance_config(config)
             sanitized[:capabilities] ||= %i[completion streaming vision tools].freeze
-            sanitized[:default_model] ||= 'claude-sonnet-4-6'
+            sanitized[:default_model] = resolve_default_model(sanitized)
             sanitized
           end
         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)
           instances = config[:instances] || config['instances']
           instances.is_a?(Hash) ? instances : {}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-anthropic
 version: !ruby/object:Gem::Version
-  version: 0.2.20
+  version: 0.2.26
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 description: Anthropic provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -101,7 +101,6 @@ files:
 - lib/legion/extensions/llm/anthropic/actors/fleet_worker.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/runners/fleet_worker.rb
 - lib/legion/extensions/llm/anthropic/translator.rb
 - lib/legion/extensions/llm/anthropic/transport/exchanges/llm_registry.rb

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

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/logging/helper'
-
-module Legion
-  module Extensions
-    module Llm
-      module Anthropic
-        # Best-effort publisher for Anthropic provider availability events.
-        class RegistryPublisher
-          include Legion::Logging::Helper
-
-          APP_ID = 'lex-llm-anthropic'
-
-          def initialize(builder: RegistryEventBuilder.new)
-            @builder = builder
-          end
-
-          def publish_models_async(models, readiness:)
-            log.debug { "publishing #{Array(models).size} Anthropic model event(s) to llm.registry" }
-            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: 'anthropic.registry.schedule_thread')
-            end
-          rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true,
-                                operation: 'anthropic.registry.schedule')
-            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
-            handle_exception(e, level: :warn, handled: true,
-                                operation: 'anthropic.registry.publish_event')
-            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
-            handle_exception(e, level: :debug, handled: true,
-                                operation: 'anthropic.registry.publishing_available?')
-            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 => e
-            handle_exception(e, level: :debug, handled: true,
-                                operation: 'anthropic.registry.transport_load')
-            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
-        end
-      end
-    end
-  end
-end