lex-llm-anthropic 0.2.17 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0c7cf1313510c485ef6ee26fffcd14bec94d99d7d10b38a9857e9635c5cf717
-  data.tar.gz: e0e3623a3199753ae17b554c3671d41572320d55348e4af8ce04634ebc9e360d
+  metadata.gz: 03b981bffa993167ee00d0bb4b122f4a92c55ed978a082d35ee3fb1237afba49
+  data.tar.gz: 9c3d7c381087b3eab19acdb504b85670c97833aff725c604c1551cb109fcf677
 SHA512:
-  metadata.gz: 6481188c16aca43c757a5d39a044186ff27da95b90b7691048ba6164e6830bb2d2f94a32a968aff02362406402c6cb24f9b831cbb51a4b1b74f3a82310f40462
-  data.tar.gz: 83a1479648dfdd1c47ed50af21285f96030e60f19bc7b70cc02c5f781e3cc898393aeed6c08ee27a6244e90fff916ef03ceba6c1c0b023d0f426f273c40b9951
+  metadata.gz: 7dab8f8bd7972ea48ce388f3fe72688d21ad2a7c960fef5112673f71bbf2f356aa233a5e00d73c99e766e8ae1b6003a86e1afb258f31cbc153a4c861dcb60f06
+  data.tar.gz: 1e1eed5d32c804b2a030ead997aa1a1be86692e13333842a0ad6517a78e94a1307fa919e2791d0c3b2a917778735deb0b35f63638ffcc486d806709eb091c217

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 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
+
+## 0.2.19 - 2026-06-15
+
+- **CapabilityPolicy integration** — Streaming and tools from `:provider_envelope`; vision/thinking default false unless explicitly enabled via settings. Settings overrides at provider/instance/model level supported.
+
+## 0.2.18 - 2026-06-13
+
+- **Gemfile cleanup** — Remove local path overrides; all dependencies resolve from gemspec via rubygems.
+- 135 examples, 0 failures; 20 files, 0 rubocop offenses.
+
 ## 0.2.17 - 2026-06-10
 
 - **Canonical provider translator (Phase 3)** — New `Translator` class implementing the Anthropic↔canonical boundary per N×N routing design. Public interface: `render_request(canonical_request)`, `parse_response(wire)`, `parse_chunk(raw)`, `capabilities`. Extracted from existing `Provider` render/parse methods — behaviour preserved, not rewritten (translator.rb).

data/Gemfile

@@ -2,9 +2,6 @@
 
 source 'https://rubygems.org'
 
-transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
-gem 'legion-transport', path: transport_path if File.directory?(transport_path)
-
 gemspec
 
 group :development do

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.5.4'
 end

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

@@ -36,6 +36,9 @@ module Legion
               return unless defined?(Legion::LLM::Discovery)
 
               Legion::LLM::Discovery.refresh_discovered_models!(provider: :anthropic)
+
+              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!)
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'anthropic.actor.discovery_refresh')
             end

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

@@ -20,7 +20,7 @@ module Legion
             def capabilities = Capabilities
 
             def registry_publisher
-              @registry_publisher ||= RegistryPublisher.new
+              @registry_publisher ||= Legion::Extensions::Llm::RegistryPublisher.new(provider_family: :anthropic)
             end
           end
 
@@ -54,6 +54,10 @@ module Legion
           def stream_url = completion_url
           def models_url = '/v1/models'
 
+          def translator
+            @translator ||= Translator.new(config)
+          end
+
           def embed(**_provider_options)
             raise NotImplementedError, 'Anthropic does not expose embeddings through this provider'
           end
@@ -76,6 +80,8 @@ module Legion
             'claude-3-haiku'  => 200_000
           }.freeze
 
+          COMPLETION_BASE = [:completion].freeze
+
           private
 
           def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:)
@@ -186,7 +192,11 @@ module Legion
 
           def format_tool_call_message(message, thinking:, cache:)
             blocks = content_blocks(message.content, thinking:, message:, cache:)
-            message.tool_calls.each_value { |tool_call| blocks << tool_use_block(tool_call, cache:) }
+            # tool_calls is an Array of ToolCall since the adapter stopped
+            # name-keying them (name-keyed hashes silently dropped parallel
+            # same-name calls); tolerate the legacy Hash shape from old callers.
+            calls = message.tool_calls.is_a?(Hash) ? message.tool_calls.values : Array(message.tool_calls)
+            calls.each { |tool_call| blocks << tool_use_block(tool_call, cache:) }
             { role: 'assistant', content: blocks }
           end
 
@@ -274,8 +284,8 @@ module Legion
           def tool_schema(tool)
             return tool.params_schema if tool.respond_to?(:params_schema) && tool.params_schema
 
-            { type: 'object',
-              properties: tool.respond_to?(:parameters) ? tool.parameters : (tool[:parameters] || tool['parameters'] || {}), required: [] }
+            raw = tool.respond_to?(:parameters) ? tool.parameters : (tool[:parameters] || tool['parameters'])
+            Legion::Extensions::Llm::Canonical::ToolDefinition.normalize_parameters(raw)
           end
 
           def tool_choice(tool_prefs)
@@ -318,116 +328,124 @@ module Legion
 
           def parse_completion_response(response)
             body = response.body
-            content_blocks = body['content'] || []
-            usage = body['usage'] || {}
-
-            Legion::Extensions::Llm::Message.new(
-              role:                  :assistant,
-              content:               text_from(content_blocks),
-              model_id:              body['model'],
-              thinking:              thinking_from(content_blocks),
-              tool_calls:            parse_tool_calls(content_blocks),
-              input_tokens:          usage['input_tokens'],
-              output_tokens:         usage['output_tokens'],
-              cached_tokens:         usage['cache_read_input_tokens'],
-              cache_creation_tokens: cache_creation_tokens(usage),
-              thinking_tokens:       thinking_tokens(usage),
-              raw:                   body
-            )
+            canonical = translator.parse_response(body)
+            to_legacy_message(canonical, body)
           end
 
-          def text_from(blocks)
-            blocks.select { |block| block['type'] == 'text' }.map { |block| block['text'] }.join
-          end
-
-          def thinking_from(blocks)
-            thinking_block = blocks.find { |block| block['type'] == 'thinking' }
-            redacted_block = blocks.find { |block| block['type'] == 'redacted_thinking' }
-
-            Legion::Extensions::Llm::Thinking.build(
-              text:      thinking_block&.dig('thinking') || thinking_block&.dig('text'),
-              signature: thinking_block&.dig('signature') || redacted_block&.dig('data')
-            )
-          end
-
-          def cache_creation_tokens(usage)
-            cache_creation = usage['cache_creation']
-            cache_creation_values = cache_creation.values if cache_creation
+          def build_chunk(data)
+            canonical_chunk = translator.parse_chunk(data)
+            return nil if canonical_chunk.nil?
 
-            usage['cache_creation_input_tokens'] || cache_creation_values&.compact&.sum
+            to_legacy_chunk(canonical_chunk, data)
           end
 
-          def thinking_tokens(usage)
-            usage.dig('output_tokens_details', 'thinking_tokens') ||
-              usage.dig('output_tokens_details', 'reasoning_tokens') ||
-              usage['thinking_tokens'] ||
-              usage['reasoning_tokens']
+          def to_legacy_message(canonical, raw_body)
+            usage = canonical.usage
+            Legion::Extensions::Llm::Message.new(
+              role:                  :assistant,
+              content:               canonical.text,
+              model_id:              canonical.model,
+              thinking:              if canonical.thinking
+                                       Legion::Extensions::Llm::Thinking.build(
+                                         text:      canonical.thinking.content,
+                                         signature: canonical.thinking.signature
+                                       )
+                                     end,
+              tool_calls:            legacy_tool_calls(canonical.tool_calls),
+              input_tokens:          usage&.input_tokens,
+              output_tokens:         usage&.output_tokens,
+              cached_tokens:         usage&.cache_read_tokens,
+              cache_creation_tokens: usage&.cache_write_tokens,
+              thinking_tokens:       usage&.thinking_tokens,
+              raw:                   raw_body
+            )
           end
 
-          def build_chunk(data)
-            delta_type = data.dig('delta', 'type')
-
+          def to_legacy_chunk(canonical_chunk, raw_data)
             Legion::Extensions::Llm::Chunk.new(
               role:          :assistant,
-              content:       delta_type == 'text_delta' ? data.dig('delta', 'text') : nil,
-              model_id:      data.dig('message', 'model'),
-              thinking:      Legion::Extensions::Llm::Thinking.build(
-                text:      delta_type == 'thinking_delta' ? data.dig('delta', 'thinking') : nil,
-                signature: delta_type == 'signature_delta' ? data.dig('delta', 'signature') : nil
-              ),
-              input_tokens:  data.dig('message', 'usage', 'input_tokens'),
-              output_tokens: data.dig('message', 'usage', 'output_tokens') || data.dig('usage', 'output_tokens'),
-              tool_calls:    extract_streaming_tool_calls(data, delta_type)
+              content:       canonical_chunk.text_delta? ? canonical_chunk.delta : nil,
+              model_id:      raw_data.dig('message', 'model'),
+              thinking:      if canonical_chunk.thinking_delta?
+                               Legion::Extensions::Llm::Thinking.build(
+                                 text:      canonical_chunk.delta,
+                                 signature: canonical_chunk.signature
+                               )
+                             end,
+              input_tokens:  canonical_chunk.usage&.input_tokens,
+              output_tokens: canonical_chunk.usage&.output_tokens,
+              tool_calls:    legacy_streaming_tool_calls(canonical_chunk)
             )
           end
 
-          def extract_streaming_tool_calls(data, _delta_type)
-            content_block = data['content_block']
-            return nil unless content_block && content_block['type'] == 'tool_use'
+          def legacy_tool_calls(canonical_tool_calls)
+            return nil if canonical_tool_calls.nil? || canonical_tool_calls.empty?
 
-            { content_block['id'] => Legion::Extensions::Llm::ToolCall.new(
-              id: content_block['id'], name: content_block['name'], arguments: ''
-            ) }
-          end
-
-          def parse_tool_calls(content_blocks)
-            blocks = Array(content_blocks).select { |block| block && block['type'] == 'tool_use' }
-            return nil if blocks.empty?
-
-            blocks.to_h do |block|
+            canonical_tool_calls.to_h do |tc|
               [
-                block['id'],
+                tc.id,
                 Legion::Extensions::Llm::ToolCall.new(
-                  id:        block['id'],
-                  name:      block['name'],
-                  arguments: block['input'] || {}
+                  id: tc.id, name: tc.name, arguments: tc.arguments || {}
                 )
               ]
             end
           end
 
+          def legacy_streaming_tool_calls(canonical_chunk)
+            return nil unless canonical_chunk.tool_call_delta?
+
+            tc = canonical_chunk.tool_call
+            return nil unless tc
+
+            { tc.id => Legion::Extensions::Llm::ToolCall.new(
+              id: tc.id, name: tc.name, arguments: tc.arguments || ''
+            ) }
+          end
+
           def parse_list_models_response(response, provider, _capabilities)
             Array(response.body['data']).map do |model|
               model_id = model.fetch('id')
               detail = model_detail(model_id)
               ctx = detail&.dig(:context_window) || infer_context_window(model_id)
+              resolved = resolve_model_capabilities(model_id)
               Legion::Extensions::Llm::Model::Info.new(
                 id:             model_id,
                 name:           model['display_name'] || model_id,
                 provider:       provider,
-                capabilities:   %i[completion streaming tools],
+                capabilities:   COMPLETION_BASE + resolved[:capabilities],
                 context_length: ctx,
                 metadata:       model.merge('created_at' => model['created_at']).compact
               )
             end
           end
 
-          def infer_context_window(model_id)
-            CONTEXT_WINDOWS.find { |prefix, _| model_id.start_with?(prefix) }&.last
+          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
+            )
           end
 
-          def model_detail(model_name)
-            fetch_model_detail(model_name)
+          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
 
           def fetch_model_detail(model_name)

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

@@ -106,54 +106,68 @@ module Legion
             )
           end
 
-          # Parse chunk: raw streaming event to Canonical::Chunk.
+          # Parse chunk: raw Anthropic SSE event to Canonical::Chunk.
+          # Real Anthropic events use top-level types like content_block_delta, message_delta,
+          # content_block_start; the delta kind is nested inside delta.type.
           def parse_chunk(raw)
             return nil unless raw.is_a?(Hash) && (raw.key?(:type) || raw.key?('type'))
 
-            type = raw[:type] || raw['type']
+            type = (raw[:type] || raw['type']).to_s
+            delta = raw[:delta] || raw['delta'] || {}
+            delta = {} unless delta.is_a?(Hash)
+            delta_type = (delta[:type] || delta['type']).to_s
 
             case type
-            when 'text_delta', :text_delta
+            when 'content_block_delta'
+              parse_content_block_delta(raw, delta, delta_type)
+            when 'content_block_start'
+              parse_content_block_start(raw)
+            when 'message_start'
+              parse_message_start(raw)
+            when 'message_delta'
+              parse_message_delta(raw, delta)
+            when 'message_stop'
+              Canonical::Chunk.done(
+                request_id:  raw[:request_id] || '',
+                stop_reason: map_stop_reason(delta[:stop_reason] || delta['stop_reason'])
+              )
+            when 'text_delta'
               Canonical::Chunk.text_delta(
                 delta:       extract_delta(raw, 'text_delta'),
                 request_id:  raw[:request_id],
-                block_index: raw[:block_index]
+                block_index: raw[:block_index] || raw['index']
               )
-            when 'thinking_delta', :thinking_delta
-              delta_obj = raw[:delta] || raw['delta']
-              sig_from_delta = (delta_obj[:signature] || delta_obj['signature'] if delta_obj.is_a?(Hash))
-
+            when 'thinking_delta'
+              sig_from_delta = (delta[:signature] || delta['signature'] if delta.any?)
               Canonical::Chunk.thinking_delta(
                 delta:       extract_delta(raw, 'thinking_delta'),
                 request_id:  raw[:request_id],
-                block_index: raw[:block_index],
+                block_index: raw[:block_index] || raw['index'],
                 signature:   raw[:signature] || raw['signature'] || sig_from_delta
               )
-            when 'tool_call_delta', :tool_call_delta
+            when 'tool_call_delta'
               tc = extract_tool_call_from_chunk(raw)
               return nil unless tc
 
               Canonical::Chunk.tool_call_delta(
                 tool_call:   tc,
                 request_id:  raw[:request_id],
-                block_index: raw[:block_index]
+                block_index: raw[:block_index] || raw['index']
               )
-            when 'error', :error
+            when 'error'
               Canonical::Chunk.error_chunk(
                 error:      raw[:error] || raw['error'] || 'unknown',
                 request_id: raw[:request_id] || '',
                 metadata:   raw[:metadata] || raw['metadata'] || {}
               )
-            when 'done', :done
+            when 'done'
               usage = (Canonical::Usage.from_hash(raw[:usage] || raw['usage'] || {}) if raw[:usage] || raw['usage'])
-
               Canonical::Chunk.done(
                 request_id:  raw[:request_id] || '',
                 usage:       usage,
                 stop_reason: map_stop_reason(raw[:stop_reason] || raw['stop_reason'])
               )
             else
-              # Per G20d: ignore unknown chunk types on consume
               log.debug("[anthropic translator] ignoring unknown chunk type: #{type.inspect}")
               nil
             end
@@ -233,43 +247,48 @@ module Legion
           end
 
           def content_block_to_wire(block)
-            case block.type
-            when :thinking
-              { type: 'thinking', thinking: block.text || '' }
-            when :tool_use
-              { type: 'tool_use', id: block.id, name: block.name, input: block.input || {} }
-            when :tool_result
-              { type: 'tool_result', tool_use_id: block.tool_use_id,
-                content: [{ type: 'text', text: block.text || '' }] }
-            when :image
-              { type: 'image', source: { type: block.source_type || 'base64',
-                                         media_type: block.media_type, data: block.data } }
-            else
-              { type: 'text', text: block.text || '' }
-            end
+            wire = case block.type
+                   when :thinking
+                     { type: 'thinking', thinking: block.text || '' }
+                   when :tool_use
+                     { type: 'tool_use', id: block.id, name: block.name, input: block.input || {} }
+                   when :tool_result
+                     { type: 'tool_result', tool_use_id: block.tool_use_id,
+                       content: [{ type: 'text', text: block.text || '' }] }
+                   when :image
+                     { type: 'image', source: { type: block.source_type || 'base64',
+                                                media_type: block.media_type, data: block.data } }
+                   else
+                     { type: 'text', text: block.text || '' }
+                   end
+            wire[:cache_control] = block.cache_control if block.cache_control
+            wire
           end
 
           def hash_block_to_wire(block)
             block_type = block[:type] || block['type']
-
-            case block_type
-            when 'image'
-              { type: 'image', source: block[:source] || block['source'] || {} }
-            when 'tool_result'
-              {
-                type:        'tool_result',
-                tool_use_id: block[:tool_use_id] || block['tool_use_id'],
-                content:     Array(block[:content] || block['content']).map do |item|
-                  if item.is_a?(Hash)
-                    { type: 'text', text: item[:text] || item['text'] || '' }
-                  else
-                    { type: 'text', text: item.to_s }
-                  end
-                end
-              }
-            else
-              block
-            end
+            cc = block[:cache_control] || block['cache_control']
+
+            wire = case block_type
+                   when 'image'
+                     { type: 'image', source: block[:source] || block['source'] || {} }
+                   when 'tool_result'
+                     {
+                       type:        'tool_result',
+                       tool_use_id: block[:tool_use_id] || block['tool_use_id'],
+                       content:     Array(block[:content] || block['content']).map do |item|
+                         if item.is_a?(Hash)
+                           { type: 'text', text: item[:text] || item['text'] || '' }
+                         else
+                           { type: 'text', text: item.to_s }
+                         end
+                       end
+                     }
+                   else
+                     return block
+                   end
+            wire[:cache_control] = cc if cc
+            wire
           end
 
           # --- system content ---
@@ -303,12 +322,12 @@ module Legion
               name = tool.is_a?(Canonical::ToolDefinition) ? tool.name : (tool[:name] || tool['name'])
               desc = tool.is_a?(Canonical::ToolDefinition) ? tool.description : (tool[:description] || tool['description'] || '')
               params = if tool.is_a?(Canonical::ToolDefinition)
-                         tool.parameters || {}
+                         tool.parameters
                        else
-                         tool[:parameters] || tool['parameters'] || {}
+                         Canonical::ToolDefinition.normalize_parameters(tool[:parameters] || tool['parameters'])
                        end
 
-              { name: name, description: desc, input_schema: { type: 'object', properties: params } }
+              { name: name, description: desc, input_schema: params }
             end
           end
 
@@ -484,6 +503,91 @@ module Legion
 
           # --- chunk parsing ---
 
+          # --- Anthropic wire-format SSE event parsers ---
+
+          def parse_content_block_delta(raw, delta, delta_type)
+            index = raw[:index] || raw['index']
+            case delta_type
+            when 'text_delta'
+              Canonical::Chunk.text_delta(
+                delta:       delta[:text] || delta['text'] || '',
+                request_id:  raw[:request_id],
+                block_index: index
+              )
+            when 'thinking_delta'
+              Canonical::Chunk.thinking_delta(
+                delta:       delta[:thinking] || delta['thinking'] || '',
+                request_id:  raw[:request_id],
+                block_index: index
+              )
+            when 'signature_delta'
+              Canonical::Chunk.thinking_delta(
+                delta:       '',
+                request_id:  raw[:request_id],
+                block_index: index,
+                signature:   delta[:signature] || delta['signature']
+              )
+            when 'input_json_delta'
+              tc = Canonical::ToolCall.new(
+                id: nil, exchange_id: nil, name: nil, source: nil,
+                arguments: delta[:partial_json] || delta['partial_json'] || '',
+                status: nil, duration_ms: nil, result: nil, error: nil,
+                started_at: nil, finished_at: nil, category: nil,
+                data_handling_classification: nil, policy_decision: nil
+              )
+              Canonical::Chunk.tool_call_delta(
+                tool_call:   tc,
+                request_id:  raw[:request_id],
+                block_index: index
+              )
+            else
+              log.debug("[anthropic translator] ignoring content_block_delta delta_type: #{delta_type}")
+              nil
+            end
+          end
+
+          def parse_content_block_start(raw)
+            content_block = raw[:content_block] || raw['content_block'] || {}
+            return nil unless content_block.is_a?(Hash)
+
+            block_type = content_block[:type] || content_block['type']
+            return nil unless block_type == 'tool_use'
+
+            tc = Canonical::ToolCall.build(
+              id:   content_block[:id] || content_block['id'],
+              name: content_block[:name] || content_block['name']
+            )
+            Canonical::Chunk.tool_call_delta(
+              tool_call:   tc,
+              request_id:  raw[:request_id],
+              block_index: raw[:index] || raw['index']
+            )
+          end
+
+          def parse_message_start(raw)
+            message = raw[:message] || raw['message'] || {}
+            message = {} unless message.is_a?(Hash)
+            usage_raw = message[:usage] || message['usage']
+            usage = Canonical::Usage.from_hash(usage_raw) if usage_raw.is_a?(Hash) && usage_raw.any?
+
+            Canonical::Chunk.usage_chunk(
+              usage:      usage,
+              request_id: raw[:request_id] || ''
+            )
+          end
+
+          def parse_message_delta(raw, delta)
+            usage_raw = raw[:usage] || raw['usage']
+            usage = Canonical::Usage.from_hash(usage_raw) if usage_raw.is_a?(Hash) && usage_raw.any?
+            stop_reason = delta[:stop_reason] || delta['stop_reason']
+
+            Canonical::Chunk.done(
+              request_id:  raw[:request_id] || '',
+              usage:       usage,
+              stop_reason: map_stop_reason(stop_reason)
+            )
+          end
+
           def extract_delta(raw, _type)
             delta_val = raw[:delta] || raw['delta']
             # Canonical form: delta is a plain string (e.g. from conformance fixtures).

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Anthropic
-        VERSION = '0.2.17'
+        VERSION = '0.2.21'
       end
     end
   end

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

@@ -2,11 +2,10 @@
 
 require 'legion/extensions/llm'
 require 'legion/logging/helper'
-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/translator'
 require 'legion/extensions/llm/anthropic/version'
+require_relative 'anthropic/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -18,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,
@@ -35,10 +38,7 @@ module Legion
               fleet:              {
                 enabled:             false,
                 respond_to_requests: false,
-                capabilities:        %i[chat stream_chat],
-                lanes:               [],
-                concurrency:         4,
-                queue_suffix:        nil
+                capabilities:        %i[chat stream_chat]
               }
             }
           )
@@ -121,11 +121,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 : {}
@@ -145,8 +154,7 @@ module Legion
           config.except(:api_key)
         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-anthropic
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.21
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.5.4
 description: Anthropic provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com