lex-llm-anthropic 0.2.15 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5592d5457b4e1cc4b1b64b4133ca43f99a6de148044d70606c4dfa794b724e0
-  data.tar.gz: b05ebe4ac3373d36e6fd2ad71716c372a50ac9c50641e88ac710cdb66ba6c261
+  metadata.gz: d0c7cf1313510c485ef6ee26fffcd14bec94d99d7d10b38a9857e9635c5cf717
+  data.tar.gz: e0e3623a3199753ae17b554c3671d41572320d55348e4af8ce04634ebc9e360d
 SHA512:
-  metadata.gz: a123eae076f23634c8ce0437bbdc382b53e7cdecfec5357441bf4b92b73285959911076a525bf584c726f30aceb35b4d3f9fb275039adfb7c2bd02f5fc721a50
-  data.tar.gz: 131feec5dbb20ec692f3f2e5f8bf83b1b777e16ae7c6798e8931410449eb31be9008b89e0f3ba5f8e27da6d72003de0bf639b2f37b3525b67f5fa72f3f3fb992
+  metadata.gz: 6481188c16aca43c757a5d39a044186ff27da95b90b7691048ba6164e6830bb2d2f94a32a968aff02362406402c6cb24f9b831cbb51a4b1b74f3a82310f40462
+  data.tar.gz: 83a1479648dfdd1c47ed50af21285f96030e60f19bc7b70cc02c5f781e3cc898393aeed6c08ee27a6244e90fff916ef03ceba6c1c0b023d0f426f273c40b9951

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,23 @@
 # Changelog
 
+## 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).
+- **Anthropic capability declarations** — `thinking: :signature_lifecycle`, `assistant_prefill: true`, `tool_calls: :native`, `system_content_blocks: true`, `supported_params` explicitly listed.
+- **G18 param mapping** — max_tokens, temperature, stop_sequences, seed, response_format rendered to Anthropic wire format. max_thinking_tokens → thinking.budget_tokens. top_p, top_k, frequency_penalty, presence_penalty dropped with debug log (Anthropic doesn't support).
+- **stop_reason mapping** — Maps 1:1 with canonical enums: end_turn, tool_use, max_tokens, stop_sequence, content_filter. Unmapped values default to end_turn with debug log.
+- **Thinking/signature lifecycle** — Parsing handles both canonical-form (delta as string) and Anthropic wire-form (delta as nested {text, thinking, signature} object). Supports thinking_content, redacted_thinking, signature_delta lifecycle per R4.
+- **Usage parsing** — input/output tokens, cache_read_input_tokens → cache_read_tokens, cache_creation_input_tokens → cache_write_tokens, thinking_tokens output_tokens_details.reasoning_tokens fallback chain.
+- **Conformance kit integration** — spec_helper loads `it_behaves_like('a canonical provider translator')` and `it_behaves_like('a canonical client translator')` shared examples from lex-llm gem spec directory per B1b consumer pattern.
+- **Lex-llm dependency bumped to >= 0.5.0** — Requires canonical types (B1a) and conformance kit (B1b) shipped in lex-llm 0.5.0 (gemspec).
+- **Rules** — No bare `::JSON` (Legion::JSON.load with ParseError rescue), no `_foo:` kwargs, no `**_rest`, all tunable defaults in config. 135 examples, 0 failures; 20 files, 0 rubocop offenses.
+
+## 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.

data/Gemfile

@@ -2,12 +2,8 @@
 
 source 'https://rubygems.org'
 
-group :test do
-  llm_base_path = ENV.fetch('LEX_LLM_PATH', File.expand_path('../lex-llm', __dir__))
-  transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
-  gem 'legion-transport', path: transport_path if File.directory?(transport_path)
-  gem 'lex-llm', path: llm_base_path if File.directory?(llm_base_path)
-end
+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
 

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.4.3'
+  spec.add_dependency 'lex-llm', '>= 0.5.0'
 end

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 }
               ]
@@ -256,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
@@ -271,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)
@@ -318,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
 
@@ -341,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
@@ -364,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
 
@@ -394,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'] || {}
                 )
               ]
@@ -408,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/translator.rb

@@ -0,0 +1,547 @@
+# frozen_string_literal: true
+
+require 'legion/logging/helper'
+require 'legion/extensions/llm/canonical'
+
+module Legion
+  module Extensions
+    module Llm
+      module Anthropic
+        # Canonical provider translator for Anthropic Messages API.
+        # Implements the provider-boundary contract: canonical to Anthropic wire format.
+        # Extracted from Provider render_format/parse methods - behaviour preserved, not rewritten.
+        class Translator
+          include Legion::Logging::Helper
+
+          # Anthropic-specific capabilities per the Phase 3 design.
+          CAPABILITIES = {
+            provider:              'anthropic',
+            # Thinking lifecycle: open thinking -> delta -> signature_delta -> close.
+            # Signature required alongside thinking content on Anthropic.
+            thinking:              :signature_lifecycle,
+            # Anthropic supports assistant prefill (sending partial assistant message
+            # to bias completion direction) - used in mid-stream failover (G6).
+            assistant_prefill:     true,
+            # Streaming support.
+            streaming:             true,
+            # Tool calls are first-class (tool_use content blocks).
+            tool_calls:            :native,
+            # System prompt as array of content blocks.
+            system_content_blocks: true,
+            # Supported params (G18). Unsupported params dropped with debug log.
+            supported_params:      %i[
+              max_tokens temperature stop_sequences seed response_format
+            ].freeze
+          }.freeze
+
+          def capabilities = CAPABILITIES
+          def config = @config || {}
+          def initialize(config = {}) = @config = config
+
+          # Render: Canonical::Request to Anthropic wire Hash.
+          def render_request(canonical_request)
+            msgs = canonical_request.messages || []
+            system_messages, chat_messages = msgs.partition { |msg| msg.role == :system }
+
+            system_parts = if canonical_request.system
+                             render_system_string(canonical_request.system)
+                           else
+                             render_system_content(system_messages)
+                           end
+            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)
+            model_id = canonical_request.metadata&.dig(:model) || 'claude-sonnet-4'
+
+            base = {
+              model:       model_id,
+              messages:    message_parts,
+              stream:      canonical_request.stream,
+              system:      system_parts,
+              temperature: canonical_request.params&.temperature
+            }.compact
+
+            params = canonical_request.params
+            if params
+              base[:max_tokens] = params.max_tokens
+              base[:stop_sequences] = params.stop_sequences
+              base[:seed] = params.seed
+              drop_unsupported_params(params)
+              base[:response_format] = render_response_format(params.response_format)
+            end
+
+            base[:thinking] = render_thinking_config(canonical_request) if thinking_enabled?(canonical_request)
+            base[:tools] = tools if tools && !tools.empty?
+            base[:tool_choice] = tool_choice if tool_choice
+            base[:max_tokens] ||= canonical_request.metadata&.dig(:default_max_tokens) || settings_default_max_tokens
+
+            base.compact
+          end
+
+          # Parse: Anthropic wire Hash to Canonical::Response. Accepts both Anthropic wire format
+          # (content: array of blocks) and canonical form (text: string) for conformance kit compatibility.
+          def parse_response(wire)
+            # If the wire has canonical 'text' key, pass through using Canonical::Response factory.
+            return Canonical::Response.from_hash(wire) if wire.key?(:text) || wire.key('text')
+
+            content = Array(wire[:content] || wire['content'] || [])
+            usage = wire[:usage] || wire['usage'] || {}
+            raw_usage = parse_usage(usage)
+
+            text = extract_text(content)
+            thinking = extract_thinking(content)
+            tool_calls = extract_tool_calls(content)
+            stop_reason = map_stop_reason(wire[:stop_reason] || wire['stop_reason'])
+            model = wire[:model] || wire['model']
+
+            Canonical::Response.build(
+              text:        text,
+              thinking:    thinking,
+              tool_calls:  tool_calls,
+              usage:       raw_usage,
+              stop_reason: stop_reason,
+              model:       model,
+              routing:     {},
+              metadata:    wire.except(:content, :usage, :stop_reason, :model).compact
+            )
+          end
+
+          # Parse chunk: raw streaming event to Canonical::Chunk.
+          def parse_chunk(raw)
+            return nil unless raw.is_a?(Hash) && (raw.key?(:type) || raw.key?('type'))
+
+            type = raw[:type] || raw['type']
+
+            case type
+            when 'text_delta', :text_delta
+              Canonical::Chunk.text_delta(
+                delta:       extract_delta(raw, 'text_delta'),
+                request_id:  raw[:request_id],
+                block_index: raw[:block_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))
+
+              Canonical::Chunk.thinking_delta(
+                delta:       extract_delta(raw, 'thinking_delta'),
+                request_id:  raw[:request_id],
+                block_index: raw[:block_index],
+                signature:   raw[:signature] || raw['signature'] || sig_from_delta
+              )
+            when 'tool_call_delta', :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]
+              )
+            when 'error', :error
+              Canonical::Chunk.error_chunk(
+                error:      raw[:error] || raw['error'] || 'unknown',
+                request_id: raw[:request_id] || '',
+                metadata:   raw[:metadata] || raw['metadata'] || {}
+              )
+            when 'done', :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
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'anthropic.translator.parse_chunk')
+            Canonical::Chunk.error_chunk(
+              error:      "#{e.class}: #{e.message}",
+              request_id: raw[:request_id] || ''
+            )
+          end
+
+          private
+
+          # --- render_messages ---
+
+          def render_messages(messages, thinking:)
+            messages.map do |msg|
+              case msg.role
+              when :assistant
+                render_assistant_message(msg, thinking:)
+              when :tool
+                render_tool_result_message(msg)
+              else
+                {
+                  role:    msg.role.to_s,
+                  content: render_content_blocks(msg.content)
+                }
+              end
+            end
+          end
+
+          def render_assistant_message(msg, thinking:)
+            blocks = render_content_blocks(msg.content)
+            blocks.unshift({ type: 'text', text: '' }) if thinking && msg.text.to_s.empty? && !msg.tool_calls&.empty?
+
+            Array(msg.tool_calls).each do |tc|
+              args = tc.is_a?(Canonical::ToolCall) ? tc.arguments : (tc[:arguments] || tc['arguments'] || {})
+              args = parse_json_or_hash(args)
+              blocks << {
+                type:  'tool_use',
+                id:    tc.is_a?(Canonical::ToolCall) ? tc.id : (tc[:id] || tc['id']),
+                name:  tc.is_a?(Canonical::ToolCall) ? tc.name : (tc[:name] || tc['name']),
+                input: args
+              }
+            end
+
+            { role: 'assistant', content: blocks }
+          end
+
+          def render_tool_result_message(msg)
+            tool_call_id = msg.tool_call_id
+            result_content = render_content_blocks(msg.content)
+
+            {
+              role:    'user',
+              content: [
+                { type: 'tool_result', tool_use_id: tool_call_id, content: result_content }
+              ]
+            }
+          end
+
+          def render_content_blocks(content)
+            return [{ type: 'text', text: content.to_s }] if content.is_a?(String)
+            return [] if content.nil?
+
+            blocks = Array(content).filter_map do |block|
+              case block
+              when Canonical::ContentBlock
+                content_block_to_wire(block)
+              when Hash
+                hash_block_to_wire(block)
+              else
+                { type: 'text', text: block.to_s }
+              end
+            end
+            blocks.empty? ? [] : blocks
+          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
+          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
+          end
+
+          # --- system content ---
+
+          def render_system_string(system_input)
+            return system_input if system_input.is_a?(Hash) || system_input.is_a?(Array)
+
+            [{ type: 'text', text: system_input.to_s }]
+          end
+
+          def render_system_content(messages)
+            parts = messages.flat_map do |msg|
+              content = msg.content
+              if content.is_a?(Canonical::ContentBlock) && content.type == :text
+                [{ type: 'text', text: content.text || '' }]
+              elsif content.is_a?(Array)
+                render_content_blocks(content)
+              else
+                [{ type: 'text', text: content.to_s }]
+              end
+            end
+            parts.empty? ? nil : parts
+          end
+
+          # --- tools ---
+
+          def render_tools(tools)
+            return nil if tools.nil? || tools.empty?
+
+            tools.values.map do |tool|
+              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 || {}
+                       else
+                         tool[:parameters] || tool['parameters'] || {}
+                       end
+
+              { name: name, description: desc, input_schema: { type: 'object', properties: params } }
+            end
+          end
+
+          # --- tool_choice ---
+
+          def render_tool_choice(tool_choice)
+            return nil unless tool_choice
+
+            case tool_choice
+            when :auto, 'auto'
+              { type: 'auto' }
+            when :none, 'none'
+              nil
+            when :required, 'required'
+              { type: 'any' }
+            when Hash
+              { type: 'tool', name: tool_choice[:name] || tool_choice['name'] }
+            when Symbol, String
+              { type: 'tool', name: tool_choice.to_s }
+            end
+          end
+
+          # --- thinking ---
+
+          def thinking_enabled?(canonical_request)
+            thinking = canonical_request.thinking
+            return false unless thinking
+
+            case thinking
+            when Canonical::Thinking::Config
+              thinking.enabled?
+            when Hash
+              !!thinking
+            else
+              true
+            end
+          end
+
+          def render_thinking_config(canonical_request)
+            tc = canonical_request.thinking
+            budget = case tc
+                     when Canonical::Thinking::Config
+                       tc.budget
+                     when Hash
+                       tc[:budget] || tc['budget'] || tc[:budget_tokens] || tc['budget_tokens']
+                     end
+
+            budget ||= canonical_request.params&.max_thinking_tokens
+            budget = default_thinking_budget if budget.nil? || budget.zero?
+
+            { type: 'enabled', budget_tokens: budget }
+          end
+
+          def default_thinking_budget
+            @config[:default_thinking_budget] || 1024
+          end
+
+          # --- response_format ---
+
+          def render_response_format(fmt)
+            return nil unless fmt
+
+            normalized = fmt.is_a?(Hash) ? fmt : {}
+            fmt_type = normalized[:type] || normalized['type']
+            schema = normalized[:schema] || normalized['schema'] || normalized.except(:type)
+
+            case fmt_type
+            when 'json_object', 'json_schema'
+              if schema && !schema.empty?
+                { type: 'json_schema', schema: schema }
+              else
+                { type: 'json_object' }
+              end
+            when :json, 'json'
+              { type: 'json_object' }
+            end
+          end
+
+          # --- unsupported params ---
+
+          def drop_unsupported_params(params)
+            # Anthropic Messages API does NOT support: top_p, top_k, frequency_penalty, presence_penalty.
+            unsupported = {}
+            unsupported[:top_p] = params.top_p if params.top_p
+            unsupported[:top_k] = params.top_k if params.top_k
+            unsupported[:frequency_penalty] = params.frequency_penalty if params.frequency_penalty
+            unsupported[:presence_penalty] = params.presence_penalty if params.presence_penalty
+
+            return if unsupported.empty?
+
+            log.debug("[anthropic translator] dropping unsupported params: #{unsupported.keys.join(', ')}")
+          end
+
+          # --- response parsing ---
+
+          def extract_text(blocks)
+            blocks.select { |b| (b[:type] || b['type']) == 'text' }
+                  .map { |b| b[:text] || b['text'] || '' }
+                  .join
+          end
+
+          def extract_thinking(blocks)
+            thinking_block = blocks.find { |b| (b[:type] || b['type']) == 'thinking' }
+            redacted_block = blocks.find { |b| (b[:type] || b['type']) == 'redacted_thinking' }
+
+            content = thinking_block&.dig(:thinking) || thinking_block&.dig('thinking') ||
+                      thinking_block&.dig(:text) || thinking_block&.dig('text')
+            signature = thinking_block&.dig(:signature) || thinking_block&.dig('signature') ||
+                        redacted_block&.dig(:data) || redacted_block&.dig('data')
+
+            Canonical::Thinking.from_hash({ content: content, signature: signature })
+          end
+
+          def extract_tool_calls(blocks)
+            tc_blocks = blocks.select { |b| (b[:type] || b['type']) == 'tool_use' }
+            return [] if tc_blocks.empty?
+
+            tc_blocks.map do |block|
+              args_input = block[:input] || block['input'] || {}
+              args = parse_json_or_hash(args_input)
+
+              Canonical::ToolCall.build(
+                id:        block[:id] || block['id'],
+                name:      block[:name] || block['name'],
+                arguments: args,
+                source:    :client
+              )
+            end
+          end
+
+          def parse_json_or_hash(input)
+            return input if input.is_a?(Hash)
+
+            if input.is_a?(String)
+              begin
+                Legion::JSON.load(input)
+              rescue Legion::JSON::ParseError
+                { raw_json: input }
+              end
+            else
+              {}
+            end
+          end
+
+          def parse_usage(usage)
+            Canonical::Usage.from_hash(
+              input_tokens:       usage[:input_tokens] || usage['input_tokens'],
+              output_tokens:      usage[:output_tokens] || usage['output_tokens'],
+              cache_read_tokens:  usage[:cache_read_input_tokens] || usage['cache_read_input_tokens'],
+              cache_write_tokens: cache_creation_input_tokens(usage),
+              thinking_tokens:    thinking_tokens_raw(usage)
+            )
+          end
+
+          def cache_creation_input_tokens(usage)
+            val = usage[:cache_creation_input_tokens] || usage['cache_creation_input_tokens']
+            return val if val
+
+            cache_creation = usage[:cache_creation] || usage['cache_creation']
+            return cache_creation.values.sum if cache_creation.is_a?(Hash)
+
+            val
+          end
+
+          def thinking_tokens_raw(usage)
+            usage.dig(:output_tokens_details, :thinking_tokens) ||
+              usage.dig('output_tokens_details', 'thinking_tokens') ||
+              usage.dig(:output_tokens_details, :reasoning_tokens) ||
+              usage.dig('output_tokens_details', 'reasoning_tokens') ||
+              usage[:thinking_tokens] || usage['thinking_tokens'] ||
+              usage[:reasoning_tokens] || usage['reasoning_tokens']
+          end
+
+          # --- chunk parsing ---
+
+          def extract_delta(raw, _type)
+            delta_val = raw[:delta] || raw['delta']
+            # Canonical form: delta is a plain string (e.g. from conformance fixtures).
+            return delta_val if delta_val.is_a?(String) && !delta_val.empty?
+
+            # Anthropic wire form: delta is a nested object with {text:} or {thinking:}.
+            raw.dig(:delta, :text) || raw.dig('delta', 'text') ||
+              raw.dig(:delta, :thinking) || raw.dig('delta', 'thinking') ||
+              ''
+          end
+
+          def extract_tool_call_from_chunk(raw)
+            # Canonical form: tool_call is directly in the chunk (e.g. from conformance fixtures).
+            tc_data = raw[:tool_call] || raw['tool_call']
+            return extract_tc_from_data(tc_data) if tc_data
+
+            # Anthropic wire form: tool call is in content_block with type 'tool_use'.
+            cb = raw[:content_block] || raw['content_block']
+            return nil unless cb && ((cb[:type] || cb['type']) == 'tool_use')
+
+            extract_tc_from_data(cb)
+          end
+
+          def extract_tc_from_data(data)
+            Canonical::ToolCall.build(
+              id:        data[:id] || data['id'],
+              name:      data[:name] || data['name'],
+              arguments: data[:arguments] || data['arguments'] || {}
+            )
+          end
+
+          # --- stop_reason mapping ---
+
+          def map_stop_reason(raw)
+            return nil unless raw
+
+            mapping = {
+              'end_turn'       => :end_turn,
+              'tool_use'       => :tool_use,
+              'max_tokens'     => :max_tokens,
+              'stop_sequence'  => :stop_sequence,
+              'content_filter' => :content_filter
+            }
+
+            result = mapping[raw.to_s]
+            return result if result
+
+            log.debug("[anthropic translator] unmapped stop_reason: #{raw.inspect}, defaulting to :end_turn")
+            :end_turn
+          end
+
+          # --- settings helpers ---
+
+          def settings_default_max_tokens
+            @config[:default_max_tokens] || 4096
+          end
+        end
+      end
+    end
+  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.15'
+        VERSION = '0.2.17'
       end
     end
   end

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

@@ -5,13 +5,14 @@ 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'
 
 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 +21,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 +52,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 +69,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 +82,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 +109,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 +131,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.15
+  version: 0.2.17
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.5.0
 description: Anthropic provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com
@@ -103,6 +103,7 @@ files:
 - 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
 - lib/legion/extensions/llm/anthropic/transport/messages/registry_event.rb
 - lib/legion/extensions/llm/anthropic/version.rb