lex-llm-anthropic 0.2.13 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ea542d2f08da7b03e8f42e683dca5638bdaf07966f3389cdfcccfa22f8581b0
-  data.tar.gz: b0e902241e5dd1c94c3742f9cee76d4aa2a41516829ce5c481084e70378826cc
+  metadata.gz: 9ef129fbcb71eb5500eff0ef7047dda892d97d57b21dab9567488be60cca0401
+  data.tar.gz: 3efed0ed6d287da75ac969e7dd29121b1c4e49e11f989a7fb7fed4f8c24f1ac2
 SHA512:
-  metadata.gz: 333cff908f11b23fe522c2bb79743d879b5adf0d7ce952e0b989becb9da775b58a528ba7f52ec42b7f7ef188d4d7b3db29db9700df4b17e0435c0e4de0087b1c
-  data.tar.gz: 57ad771fb6b041d74e1459bb46e5cd471f8f37f416b014bcc6873f97aca3fe0aea74c7a943ddfb3d8418bbf6ade69a0cda8fa6cc755134df53eabf9abeaaf1f1
+  metadata.gz: dfd4e546964d3994cb294860aae5d2f81476c0c067b76519b9c65506eb782e32df58fda6ede3df2f9c17095b1b7aaf7e940a2e5afc4ea34efb7d086c00e17c4f
+  data.tar.gz: 62d2e1ac960fd5084becf6d83beb966ad02556205f1d70b183ab48892a69cb3783004eddcbea08435986b7a8ec569a3f41f8b835a5e12aed63b8388b078471e3

data/.rubocop.yml

@@ -1,18 +1,52 @@
 plugins:
   - rubocop-performance
   - rubocop-rake
-  - rubocop-rspec
 
 AllCops:
-  NewCops: enable
   TargetRubyVersion: 3.4
+  NewCops: enable
   SuggestExtensions: false
 
+Layout/LineLength:
+  Max: 195
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+Metrics/MethodLength:
+  Max: 150
+Metrics/ClassLength:
+  Max: 1500
+Metrics/ModuleLength:
+  Max: 1500
 Metrics/BlockLength:
+  Max: 150
   Exclude:
-    - "*.gemspec"
-    - spec/**/*
-Metrics/MethodLength:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 110
+Metrics/BlockNesting:
+  Max: 4
+Metrics/CyclomaticComplexity:
+  Max: 50
+
+Metrics/PerceivedComplexity:
+  Max: 50
+Style/Documentation:
   Enabled: false
-RSpec/MultipleExpectations:
+Style/SymbolArray:
+  Enabled: true
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+Naming/FileName:
   Enabled: false
+Naming/PredicateMethod:
+  Enabled: false
+Metrics/ParameterLists:
+  Max: 9
+Style/RedundantConstantBase:
+  Exclude:
+    - 'spec/**/*'

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.2.16 - 2026-06-10
+
+- **Hash-backed tool support** — `format_tools` and `tool_schema` now handle both `ToolDefinition` objects and plain Hashes from `native_dispatch` via `respond_to?` checks with symbol/string key fallbacks. Prevents `NoMethodError` when tools arrive as hash-backed definitions (provider.rb).
+- **RuboCop configuration overhaul** — Relaxed metrics to match project scale: LineLength 195, MethodLength 150, ClassLength 1500, AbcSize 110, BlockNesting 4, CyclomaticComplexity/PerceivedComplexity 50. Added `Layout/HashAlignment` (table style), `Layout/SpaceAroundEqualsInParameterDefault`, `Naming/PredicateMethod` disable, `Style/RedundantConstantBase` spec exclusion. Removed `rubocop-rspec` plugin (no longer needed). All 28 specs passing, 0 offenses (.rubocop.yml).
+- **Hash alignment formatting** — Applied consistent table-style hash alignment across provider.rb, anthropic.rb, registry_event_builder.rb, fleet_worker.rb, and transport messages for readability.
+
+## 0.2.15 - 2026-06-05
+
+- **Fix RuboCop cyclomatic complexity** — Extract `extract_hash_budget` helper to reduce `thinking_budget` cyclomatic complexity from 8 to 6, meeting the 7-line threshold.
+- **Add budget_tokens support** — `extract_hash_budget` now checks `:budget_tokens` and `'budget_tokens'` keys (Anthropic API canonical) in addition to legacy `:budget`/`'budget'`.
+- **Spec and RuboCop compliance** — All 28 specs passing, 0 RuboCop offenses.
+
+## 0.2.14 - 2026-06-05
+
+- **Fix RuboCop cyclomatic complexity** — Extract `extract_hash_budget` helper to reduce `thinking_budget` complexity from 8 to 6, meeting the 7-line threshold.
+- **Fix Style/IfUnlessModifier** — Split conditional return in `thinking_budget` to avoid modifier form exceeding max line length.
+
 ## 0.2.13 - 2026-06-02
 
 - **Fix invalid anthropic-version header** — Default `api_version` was `'2023-10-02'` (typo), which Anthropic rejects. Changed to `'2023-10-16'` (anthropic.rb)

data/README.md

@@ -1,10 +1,36 @@
 # lex-llm-anthropic
 
-LegionIO LLM provider extension for Anthropic.
+LegionIO LLM provider extension for **Anthropic Claude** models.
 
-This gem lives under `Legion::Extensions::Llm::Anthropic` and depends on `lex-llm >= 0.4.3` for shared provider contracts, response normalization, fleet responder helpers, and schema primitives. It does not require `legion-llm` at runtime.
+This gem provides the `:anthropic` provider family for LegionIO's LLM routing layer, connecting to the [Anthropic Messages API](https://docs.anthropic.com/en/docs/api/messages). It handles chat completions, streaming, tool use, extended thinking, model discovery, and fleet request consumption.
 
-Load it with `require 'legion/extensions/llm/anthropic'`.
+**Namespace:** `Legion::Extensions::Llm::Anthropic`
+**Provider family:** `:anthropic`
+**Default model:** `claude-sonnet-4-6`
+**Dependency:** `lex-llm >= 0.4.3` (shared provider contracts, response normalization, fleet responders)
+
+```ruby
+require 'legion/extensions/llm/anthropic'
+```
+
+---
+
+## File Index
+
+| File | Role |
+|------|------|
+| `anthropic.rb` | Entry point; namespace, `PROVIDER_FAMILY`, default settings, instance discovery |
+| `anthropic/provider.rb` | `Provider` class — chat, stream, list_models, format/parse payloads |
+| `anthropic/registry_event_builder.rb` | Builds registry event envelopes for model availability |
+| `anthropic/registry_publisher.rb` | Publishes model events to `llm.registry` exchange (async, best-effort) |
+| `anthropic/version.rb` | `VERSION` constant |
+| `anthropic/actors/discovery_refresh.rb` | Periodic actor that refreshes Anthropic model list |
+| `anthropic/actors/fleet_worker.rb` | Subscription actor for fleet request consumption |
+| `anthropic/runners/fleet_worker.rb` | Runner entrypoint for fleet request execution |
+| `anthropic/transport/exchanges/llm_registry.rb` | Topic exchange definition for `llm.registry` |
+| `anthropic/transport/messages/registry_event.rb` | Transport message wrapper for registry events |
+
+---
 
 ## Installation
 
@@ -12,36 +38,83 @@ Load it with `require 'legion/extensions/llm/anthropic'`.
 gem 'lex-llm-anthropic', '~> 0.2'
 ```
 
-Anthropic credentials are discovered from `ANTHROPIC_API_KEY`, Claude config, configured provider instances, or an identity broker when one is available.
+---
 
-## Provider
+## Architecture
 
-`Legion::Extensions::Llm::Anthropic::Provider` registers with `Legion::Extensions::Llm::Provider` as `:anthropic` and uses Anthropic's Messages API:
+### Provider (`Provider`)
 
-- chat and streaming: `/v1/messages`
-- model discovery: `/v1/models`
-- authentication headers: `x-api-key` and `anthropic-version`
-- tools: Anthropic `tools` and `tool_choice` payload fields
-- extended thinking: Anthropic `thinking` request field and returned thinking blocks
+The `Provider` class extends the `lex-llm` base provider contract and implements:
 
-Anthropic embeddings are intentionally not exposed by this provider.
+| Method | Description |
+|--------|-------------|
+| `chat(**kwargs)` | Synchronous chat completion via `/v1/messages` |
+| `stream_chat(**kwargs)` | Streaming chat via `/v1/messages?stream=true` |
+| `list_models` | Fetches available models from `/v1/models` |
+| `format_payload(**)` | Builds Anthropic Messages API request body |
+| `parse_response(response)` | Normalizes API response to Legion envelope |
+| `parse_stream(response)` | Parses SSE stream into chunk events |
+| `build_chunk(event, state)` | Accumulates streaming state (content, tool calls, thinking) |
 
-## Configuration
+**Supported capabilities:** `:completion`, `:streaming`, `:vision`, `:tools`
+
+**API endpoints:**
+- Chat & streaming: `POST /v1/messages`
+- Model discovery: `GET /v1/models`
+
+**Authentication headers:** `x-api-key`, `anthropic-version`
+
+### Instance Discovery (`discover_instances`)
+
+The extension discovers and normalizes Anthropic credentials from four sources, in priority order:
+
+1. **Environment** — `ANTHROPIC_API_KEY`
+2. **Claude config** — `~/.claude/settings.json` under `anthropicApiKey`
+3. **Extension settings** — `Legion::Settings` at `extensions.llm.anthropic`
+4. **Identity broker** — `Legion::Identity::Broker.credential_for(:anthropic)`
+
+Named instances are supported under `extensions.llm.anthropic.instances.<name>`. Generic keys (`api_key`, `endpoint`, `version`) are normalized to Anthropic-specific keys (`anthropic_api_key`, `anthropic_api_base`, `anthropic_version`). Duplicate credentials are deduplicated by fingerprint.
+
+### Default Settings
 
 ```ruby
-Legion::Extensions::Llm.configure do |config|
-  config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY')
-  config.anthropic_version = '2023-06-01'
-end
+{
+  default_model: 'claude-sonnet-4-6',
+  endpoint: 'https://api.anthropic.com',
+  api_version: '2023-10-16',
+  default_max_tokens: 4096,
+  tier: :frontier,
+  transport: :http,
+  credentials: { api_key: 'env://ANTHROPIC_API_KEY' },
+  usage: { inference: true, embedding: false, image: false },
+  limits: { concurrency: 4 },
+  fleet: {
+    enabled: false,
+    respond_to_requests: false,
+    capabilities: %i[chat stream_chat],
+    lanes: [],
+    concurrency: 4,
+    queue_suffix: nil
+  }
+}
 ```
 
-`anthropic_api_base` can override the default `https://api.anthropic.com` endpoint for tests or compatible Anthropic gateways.
+### Registry Events (Availability Publishing)
+
+After model discovery, discovered models are published to the `llm.registry` topic exchange so other LegionIO nodes can discover Anthropic availability.
+
+| Class | Role |
+|-------|------|
+| `RegistryEventBuilder` | Builds the event envelope with model offering, health, and metadata |
+| `RegistryPublisher` | Schedules async publish; checks transport readiness before sending |
+| `Transport::Messages::RegistryEvent` | Message wrapper targeting the `llm.registry` exchange |
+| `Transport::Exchanges::LlmRegistry` | Topic exchange definition (`llm.registry`) |
 
-Named instances can use generic provider keys such as `api_key`, `endpoint`, and `version`; the extension normalizes them to Anthropic-specific provider options during discovery.
+Publishing is **best-effort** and requires transport to be loaded. Failures are logged at `debug` level and silently absorbed.
 
-## Fleet Responder
+### 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`.
+Provider instances can consume Legion LLM fleet requests. The fleet actor only starts when at least one configured instance enables `respond_to_requests`.
 
 ```yaml
 extensions:
@@ -57,4 +130,103 @@ extensions:
               - stream_chat
 ```
 
-Fleet execution is delegated to `Legion::Extensions::Llm::Fleet::ProviderResponder` from `lex-llm`. The responder owns provider invocation for this gem; routing and fleet request publication remain outside this provider extension.
+| Component | Role |
+|-----------|------|
+| `Actor::FleetWorker` | Subscription actor; checks if any instance enables fleet responding |
+| `Runners::FleetWorker` | Runner entrypoint; delegates to `lex-llm` `ProviderResponder` |
+
+Fleet execution is delegated to `Legion::Extensions::Llm::Fleet::ProviderResponder` from `lex-llm`. Routing and fleet request publication are handled outside this extension.
+
+### Model Discovery Refresh
+
+A periodic actor (`Actor::DiscoveryRefresh`) refreshes the Anthropic model list every 30 minutes (configurable via `extensions.llm.anthropic.discovery_interval`). It calls `Legion::LLM::Discovery.refresh_discovered_models!(provider: :anthropic)`.
+
+---
+
+## Configuration
+
+```ruby
+Legion::Extensions::Llm.configure do |config|
+  config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY')
+  config.anthropic_version = '2023-10-16'
+end
+```
+
+**Configurable options:**
+
+| Setting | Key | Description |
+|---------|-----|-------------|
+| API key | `anthropic_api_key` / `ANTHROPIC_API_KEY` | Required; API authentication |
+| API version | `anthropic_version` | Defaults to `2023-10-16` |
+| Endpoint | `anthropic_api_base` | Override `https://api.anthropic.com` |
+| Max tokens | `default_max_tokens` | Defaults to `4096` |
+| Discovery interval | `discovery_interval` (seconds) | Defaults to `1800` |
+
+---
+
+## Usage Examples
+
+### Chat (synchronous)
+
+```ruby
+provider = Legion::Extensions::Llm::Anthropic::Provider.new(api_key: 'sk-ant-...')
+response = provider.chat(model: 'claude-sonnet-4-6', messages: [{ role: 'user', content: 'Hello' }])
+```
+
+### Chat (streaming)
+
+```ruby
+provider.stream_chat(model: 'claude-sonnet-4-6', messages: [{ role: 'user', content: 'Hello' }]) do |chunk|
+  print chunk[:content] if chunk[:content]
+end
+```
+
+### With tools
+
+```ruby
+response = provider.chat(
+  model: 'claude-sonnet-4-6',
+  messages: [{ role: 'user', content: 'What is the weather in SF?' }],
+  tools: [{ name: 'get_weather', description: '...', input_schema: { ... } }]
+)
+```
+
+### Extended thinking
+
+```ruby
+response = provider.chat(
+  model: 'claude-sonnet-4-6',
+  messages: [{ role: 'user', content: 'Solve this math problem...' }],
+  thinking: { budget_tokens: 4096, enabled: true }
+)
+```
+
+---
+
+## Dependencies
+
+| Gem | Minimum version | Role |
+|-----|-----------------|------|
+| `lex-llm` | `>= 0.4.3` | Base provider contract, response normalization, fleet responder, auto-registration |
+| `legion-logging` | (via lex-llm) | Logging helper for diagnostics |
+| `legion-settings` | (via lex-llm) | Configuration access |
+| `legion-transport` | (via lex-llm) | Message exchange for registry events |
+
+---
+
+## Testing
+
+```bash
+bundle exec rspec    # 28 examples
+bundle exec rubocop  # 0 offenses
+```
+
+---
+
+## Design Notes
+
+- **No embeddings** — Anthropic embeddings are intentionally not exposed.
+- **No `:claude` alias** — `provider_aliases` returns `[]`; only `:anthropic` is registered.
+- **Prompt caching** — When `cache_enabled?` is true, system content and tool definitions are marked as cache breakpoints; early conversation turns are cacheable, the final message is never cached.
+- **Thinking budget** — Supports `Integer`, `Hash` (with `:budget_tokens` or legacy `:budget`), and objects responding to `#budget`. Defaults to `1024`.
+- **Context windows** — Static `CONTEXT_WINDOWS` map covers known Claude model families; `fetch_model_detail` and `infer_context_window` provide fallback inference.

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

@@ -13,7 +13,7 @@ module Legion
     module Llm
       module Anthropic
         module Actor
-          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation
+          class DiscoveryRefresh < Legion::Extensions::Actors::Every
             include Legion::Logging::Helper
 
             REFRESH_INTERVAL = 1800

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

@@ -8,7 +8,7 @@ module Legion
     module Llm
       module Anthropic
         # Anthropic Messages API provider implementation for the Legion::Extensions::Llm contract.
-        class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
+        class Provider < Legion::Extensions::Llm::Provider
           include Legion::Logging::Helper
 
           class << self
@@ -45,7 +45,7 @@ module Legion
 
           def headers
             identity_headers.merge({
-              'x-api-key' => config.anthropic_api_key,
+              'x-api-key'         => config.anthropic_api_key,
               'anthropic-version' => config.anthropic_version || settings[:api_version] || '2023-06-01'
             }.compact)
           end
@@ -67,18 +67,18 @@ module Legion
           end
 
           CONTEXT_WINDOWS = {
-            'claude-opus-4' => 200_000,
+            'claude-opus-4'   => 200_000,
             'claude-sonnet-4' => 200_000,
-            'claude-haiku-4' => 200_000,
-            'claude-3-5' => 200_000,
-            'claude-3-opus' => 200_000,
+            'claude-haiku-4'  => 200_000,
+            'claude-3-5'      => 200_000,
+            'claude-3-opus'   => 200_000,
             'claude-3-sonnet' => 200_000,
-            'claude-3-haiku' => 200_000
+            'claude-3-haiku'  => 200_000
           }.freeze
 
           private
 
-          def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:) # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
+          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 }
 
@@ -87,15 +87,15 @@ module Legion
             cacheable_count = caching ? [chat_messages.size - exclude_count, 0].max : 0
 
             {
-              model: model.id,
-              messages: format_messages(chat_messages, thinking: thinking_enabled?(thinking), cacheable_count:),
-              stream: stream,
-              max_tokens: model.max_tokens || settings[:default_max_tokens] || 4096,
-              system: system_content(system_messages, cache: caching),
-              thinking: thinking_payload(thinking),
-              temperature: temperature,
-              tools: format_tools(tools, cache: caching),
-              tool_choice: tool_choice(tool_prefs),
+              model:         model.id,
+              messages:      format_messages(chat_messages, thinking: thinking_enabled?(thinking), cacheable_count:),
+              stream:        stream,
+              max_tokens:    model.max_tokens || settings[:default_max_tokens] || 4096,
+              system:        system_content(system_messages, cache: caching),
+              thinking:      thinking_payload(thinking),
+              temperature:   temperature,
+              tools:         format_tools(tools, cache: caching),
+              tool_choice:   tool_choice(tool_prefs),
               output_config: output_config(schema)
             }.compact
           end
@@ -123,7 +123,7 @@ module Legion
                 format_tool_result_message(message, cache:)
               else
                 {
-                  role: anthropic_role(message.role),
+                  role:    anthropic_role(message.role),
                   content: content_blocks(message.content, thinking:, message:, cache:)
                 }
               end
@@ -167,11 +167,11 @@ module Legion
               next unless attachment.image?
 
               {
-                type: 'image',
+                type:   'image',
                 source: {
-                  type: 'base64',
+                  type:       'base64',
                   media_type: attachment.mime_type,
-                  data: attachment.encoded
+                  data:       attachment.encoded
                 }
               }
             end
@@ -192,10 +192,10 @@ module Legion
 
           def tool_use_block(tool_call, cache: false)
             {
-              type: 'tool_use',
-              id: tool_call.id,
-              name: tool_call.name,
-              input: tool_call.arguments,
+              type:          'tool_use',
+              id:            tool_call.id,
+              name:          tool_call.name,
+              input:         tool_call.arguments,
               cache_control: { type: 'ephemeral' }
             }.tap do |block|
               block.delete(:cache_control) unless cache
@@ -204,12 +204,12 @@ module Legion
 
           def format_tool_result_message(message, cache: false)
             {
-              role: 'user',
+              role:    'user',
               content: [
                 {
-                  type: 'tool_result',
-                  tool_use_id: message.tool_call_id,
-                  content: content_blocks(message.content, cache:),
+                  type:          'tool_result',
+                  tool_use_id:   message.tool_call_id,
+                  content:       content_blocks(message.content, cache:),
                   cache_control: { type: 'ephemeral' }
                 }.tap { |block| block.delete(:cache_control) unless cache }
               ]
@@ -231,12 +231,17 @@ module Legion
 
           def thinking_budget(thinking)
             return thinking if thinking.is_a?(Integer)
-            return thinking[:budget] || thinking['budget'] if thinking.is_a?(Hash)
+            return extract_hash_budget(thinking) if thinking.is_a?(Hash)
             return thinking.budget if thinking.respond_to?(:budget) && thinking.budget
 
             1024
           end
 
+          # Anthropic API uses :budget_tokens, but legacy config may use :budget
+          def extract_hash_budget(thinking)
+            thinking[:budget_tokens] || thinking['budget_tokens'] || thinking[:budget] || thinking['budget']
+          end
+
           def thinking_block(thinking)
             return nil unless thinking
 
@@ -251,9 +256,12 @@ module Legion
             return nil if tools.empty?
 
             tool_array = tools.values.map do |tool|
+              # Tools can be ToolDefinition objects or plain Hashes from native_dispatch.
+              tool_name = tool.respond_to?(:name) ? tool.name : (tool[:name] || tool['name'])
+              tool_desc = tool.respond_to?(:description) ? tool.description : (tool[:description] || tool['description'] || '')
               {
-                name: tool.name,
-                description: tool.description,
+                name:         tool_name,
+                description:  tool_desc,
                 input_schema: tool_schema(tool)
               }
             end
@@ -266,7 +274,8 @@ module Legion
           def tool_schema(tool)
             return tool.params_schema if tool.respond_to?(:params_schema) && tool.params_schema
 
-            { type: 'object', properties: {}, required: [] }
+            { type: 'object',
+              properties: tool.respond_to?(:parameters) ? tool.parameters : (tool[:parameters] || tool['parameters'] || {}), required: [] }
           end
 
           def tool_choice(tool_prefs)
@@ -313,17 +322,17 @@ module Legion
             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'],
+              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
+              thinking_tokens:       thinking_tokens(usage),
+              raw:                   body
             )
           end
 
@@ -336,7 +345,7 @@ module Legion
             redacted_block = blocks.find { |block| block['type'] == 'redacted_thinking' }
 
             Legion::Extensions::Llm::Thinking.build(
-              text: thinking_block&.dig('thinking') || thinking_block&.dig('text'),
+              text:      thinking_block&.dig('thinking') || thinking_block&.dig('text'),
               signature: thinking_block&.dig('signature') || redacted_block&.dig('data')
             )
           end
@@ -359,16 +368,16 @@ module Legion
             delta_type = data.dig('delta', 'type')
 
             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,
+              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'),
+              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)
+              tool_calls:    extract_streaming_tool_calls(data, delta_type)
             )
           end
 
@@ -389,8 +398,8 @@ module Legion
               [
                 block['id'],
                 Legion::Extensions::Llm::ToolCall.new(
-                  id: block['id'],
-                  name: block['name'],
+                  id:        block['id'],
+                  name:      block['name'],
                   arguments: block['input'] || {}
                 )
               ]
@@ -403,12 +412,12 @@ module Legion
               detail = model_detail(model_id)
               ctx = detail&.dig(:context_window) || infer_context_window(model_id)
               Legion::Extensions::Llm::Model::Info.new(
-                id: model_id,
-                name: model['display_name'] || model_id,
-                provider: provider,
-                capabilities: %i[completion streaming tools],
+                id:             model_id,
+                name:           model['display_name'] || model_id,
+                provider:       provider,
+                capabilities:   %i[completion streaming tools],
                 context_length: ctx,
-                metadata: model.merge('created_at' => model['created_at']).compact
+                metadata:       model.merge('created_at' => model['created_at']).compact
               )
             end
           end

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

@@ -13,8 +13,8 @@ module Legion
           def model_available(model, readiness:)
             registry_event_class.available(
               model_offering(model),
-              runtime: runtime_metadata,
-              health: model_health(readiness),
+              runtime:  runtime_metadata,
+              health:   model_health(readiness),
               metadata: model_metadata(model)
             )
           end
@@ -23,14 +23,14 @@ module Legion
 
           def model_offering(model)
             {
-              provider_family: :anthropic,
+              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
+              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
 
@@ -49,7 +49,7 @@ module Legion
 
           def model_limits(model)
             {
-              context_window: model.context_window,
+              context_window:    model.context_window,
               max_output_tokens: model.max_output_tokens
             }.compact
           end

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

@@ -14,12 +14,12 @@ module Legion
 
             def handle_fleet_request(payload, delivery: nil, properties: nil)
               Legion::Extensions::Llm::Fleet::ProviderResponder.call(
-                payload: payload,
-                provider_family: Anthropic::PROVIDER_FAMILY,
-                provider_class: Anthropic::Provider,
+                payload:            payload,
+                provider_family:    Anthropic::PROVIDER_FAMILY,
+                provider_class:     Anthropic::Provider,
                 provider_instances: -> { Anthropic.discover_instances },
-                delivery: delivery,
-                properties: properties
+                delivery:           delivery,
+                properties:         properties
               )
             end
           end

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

@@ -30,7 +30,7 @@ module Legion
                 @options[:app_id] || RegistryPublisher::APP_ID
               end
 
-              def persistent # rubocop:disable Naming/PredicateMethod
+              def persistent
                 false
               end
             end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Anthropic
-        VERSION = '0.2.13'
+        VERSION = '0.2.16'
       end
     end
   end

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

@@ -11,7 +11,7 @@ module Legion
   module Extensions
     module Llm
       # Anthropic provider extension namespace.
-      module Anthropic # rubocop:disable Metrics/ModuleLength
+      module Anthropic
         extend ::Legion::Extensions::Core if ::Legion::Extensions.const_defined?(:Core, false)
         extend Legion::Logging::Helper
         extend Legion::Extensions::Llm::AutoRegistration
@@ -20,24 +20,24 @@ module Legion
 
         def self.default_settings
           ::Legion::Extensions::Llm.provider_settings(
-            family: PROVIDER_FAMILY,
+            family:   PROVIDER_FAMILY,
             instance: {
-              default_model: 'claude-sonnet-4-6',
-              endpoint: 'https://api.anthropic.com',
-              api_version: '2023-10-16',
+              default_model:      'claude-sonnet-4-6',
+              endpoint:           'https://api.anthropic.com',
+              api_version:        '2023-10-16',
               default_max_tokens: 4096,
-              tier: :frontier,
-              transport: :http,
-              credentials: { api_key: 'env://ANTHROPIC_API_KEY' },
-              usage: { inference: true, embedding: false, image: false },
-              limits: { concurrency: 4 },
-              fleet: {
-                enabled: false,
+              tier:               :frontier,
+              transport:          :http,
+              credentials:        { api_key: 'env://ANTHROPIC_API_KEY' },
+              usage:              { inference: true, embedding: false, image: false },
+              limits:             { concurrency: 4 },
+              fleet:              {
+                enabled:             false,
                 respond_to_requests: false,
-                capabilities: %i[chat stream_chat],
-                lanes: [],
-                concurrency: 4,
-                queue_suffix: nil
+                capabilities:        %i[chat stream_chat],
+                lanes:               [],
+                concurrency:         4,
+                queue_suffix:        nil
               }
             }
           )
@@ -51,16 +51,16 @@ module Legion
           []
         end
 
-        def self.discover_instances # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def self.discover_instances
           candidates = {}
 
           env_key = CredentialSources.env('ANTHROPIC_API_KEY')
           if env_key
             candidates[:env] = {
-              api_key: env_key,
-              anthropic_api_key: env_key,
-              tier: :frontier,
-              source: CredentialSources.source_tag(:env, 'ANTHROPIC_API_KEY'),
+              api_key:                env_key,
+              anthropic_api_key:      env_key,
+              tier:                   :frontier,
+              source:                 CredentialSources.source_tag(:env, 'ANTHROPIC_API_KEY'),
               credential_fingerprint: CredentialSources.credential_fingerprint(env_key)
             }
           end
@@ -68,10 +68,10 @@ module Legion
           claude_key = CredentialSources.claude_config_value(:anthropicApiKey)
           if claude_key
             candidates[:claude] = {
-              api_key: claude_key,
-              anthropic_api_key: claude_key,
-              tier: :frontier,
-              source: CredentialSources.source_tag(:file, '~/.claude/settings.json', 'anthropicApiKey'),
+              api_key:                claude_key,
+              anthropic_api_key:      claude_key,
+              tier:                   :frontier,
+              source:                 CredentialSources.source_tag(:file, '~/.claude/settings.json', 'anthropicApiKey'),
               credential_fingerprint: CredentialSources.credential_fingerprint(claude_key)
             }
           end
@@ -81,10 +81,10 @@ module Legion
             settings_key = settings_config[:api_key] || settings_config['api_key']
             if settings_key
               candidates[:settings] = normalize_instance_config(settings_config).merge(
-                api_key: settings_key,
-                anthropic_api_key: settings_key,
-                tier: :frontier,
-                source: CredentialSources.source_tag(:settings, 'extensions.llm.anthropic'),
+                api_key:                settings_key,
+                anthropic_api_key:      settings_key,
+                tier:                   :frontier,
+                source:                 CredentialSources.source_tag(:settings, 'extensions.llm.anthropic'),
                 credential_fingerprint: CredentialSources.credential_fingerprint(settings_key)
               )
             end
@@ -108,10 +108,10 @@ module Legion
             broker_cred = Legion::Identity::Broker.credential_for(:anthropic)
             if broker_cred
               candidates[:broker] = {
-                api_key: broker_cred,
-                anthropic_api_key: broker_cred,
-                tier: :frontier,
-                source: CredentialSources.source_tag(:broker, 'identity', 'anthropic'),
+                api_key:                broker_cred,
+                anthropic_api_key:      broker_cred,
+                tier:                   :frontier,
+                source:                 CredentialSources.source_tag(:broker, 'identity', 'anthropic'),
                 credential_fingerprint: CredentialSources.credential_fingerprint(broker_cred)
               }
             end
@@ -130,7 +130,7 @@ module Legion
           instances.is_a?(Hash) ? instances : {}
         end
 
-        def self.normalize_instance_config(config) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        def self.normalize_instance_config(config)
           normalized = config.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
           normalized[:anthropic_api_key] ||= normalized.delete(:api_key)
           normalized[:anthropic_api_base] ||= normalized.delete(:base_url)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-anthropic
 version: !ruby/object:Gem::Version
-  version: 0.2.13
+  version: 0.2.16
 platform: ruby
 authors:
 - LegionIO