lex-llm-anthropic 0.2.11 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1237cef4710e768a52ab02e062379ed70a6f2ee7456cca1b5a45cfb03489c5c4
-  data.tar.gz: bb9a132592136f7c64c4f982a6d1f9896348e0362da9d46d77fb846566b6a2d8
+  metadata.gz: 7ea542d2f08da7b03e8f42e683dca5638bdaf07966f3389cdfcccfa22f8581b0
+  data.tar.gz: b0e902241e5dd1c94c3742f9cee76d4aa2a41516829ce5c481084e70378826cc
 SHA512:
-  metadata.gz: 9e138f44cbb23a70c48dc489e53bc6dff5fef7964db248b41f519b37a71e839dee7aa2dcbc26ce7cc5aa41e3df5720c0889537c497b6fb25bfb31053864d0066
-  data.tar.gz: 725a59b156f68280cbc9d276eccb6c90e21c638900dbf6d81405588a15bd0ce00c3413555c311aef411162669b959635e9f3d4363fcd124d364eedf8725ef189
+  metadata.gz: 333cff908f11b23fe522c2bb79743d879b5adf0d7ce952e0b989becb9da775b58a528ba7f52ec42b7f7ef188d4d7b3db29db9700df4b17e0435c0e4de0087b1c
+  data.tar.gz: 57ad771fb6b041d74e1459bb46e5cd471f8f37f416b014bcc6873f97aca3fe0aea74c7a943ddfb3d8418bbf6ade69a0cda8fa6cc755134df53eabf9abeaaf1f1

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 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)
+- **Add per-provider discovery refresh actor** — New `actors/discovery_refresh.rb` that only refreshes Anthropic models, avoiding coupling to other providers' discovery cycles
+
+## 0.2.12 - 2026-06-01
+
+- Add `cache_control` markers to Anthropic Messages API requests for prompt caching
+- System content and tool definitions are marked as cache breakpoints when `cache_enabled?`
+- Early conversation turns are cacheable; final message is never cached (prefix break guard)
+- Uses `cache_control_prefix_tokens` from lex-llm base provider for exclude count (default 4)
+
 ## 0.2.11 - 2026-05-21
 
 - Add `api_version` and `default_max_tokens` to default_settings

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+begin
+  require 'legion/extensions/actors/every'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
+return unless defined?(Legion::Extensions::Actors::Every)
+
+module Legion
+  module Extensions
+    module Llm
+      module Anthropic
+        module Actor
+          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation
+            include Legion::Logging::Helper
+
+            REFRESH_INTERVAL = 1800
+
+            def runner_class    = self.class
+            def runner_function = 'manual'
+            def run_now?        = true
+            def use_runner?     = false
+            def check_subtask?  = false
+            def generate_task?  = false
+
+            def time
+              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+
+              Legion::Settings.dig(:extensions, :llm, :anthropic, :discovery_interval) || REFRESH_INTERVAL
+            end
+
+            def manual
+              log.debug('[anthropic][discovery_refresh] refreshing model list')
+              return unless defined?(Legion::LLM::Discovery)
+
+              Legion::LLM::Discovery.refresh_discovered_models!(provider: :anthropic)
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'anthropic.actor.discovery_refresh')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -78,19 +78,23 @@ module Legion
 
           private
 
-          def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:) # rubocop:disable Metrics/ParameterLists
+          def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:) # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize
             log_render_payload(messages:, tools:, model:, stream:, schema:)
             system_messages, chat_messages = messages.partition { |message| message.role == :system }
 
+            caching = cache_enabled?
+            exclude_count = caching ? [cache_control_prefix_tokens, 1].max : 0
+            cacheable_count = caching ? [chat_messages.size - exclude_count, 0].max : 0
+
             {
               model: model.id,
-              messages: format_messages(chat_messages, thinking: thinking_enabled?(thinking)),
+              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),
+              system: system_content(system_messages, cache: caching),
               thinking: thinking_payload(thinking),
               temperature: temperature,
-              tools: format_tools(tools),
+              tools: format_tools(tools, cache: caching),
               tool_choice: tool_choice(tool_prefs),
               output_config: output_config(schema)
             }.compact
@@ -103,21 +107,24 @@ module Legion
             end
           end
 
-          def system_content(messages)
-            content = messages.flat_map { |message| content_blocks(message.content) }
+          def system_content(messages, cache: false)
+            content = messages.flat_map do |message|
+              content_blocks(message.content, cache:)
+            end
             content.empty? ? nil : content
           end
 
-          def format_messages(messages, thinking:)
-            messages.map do |message|
+          def format_messages(messages, thinking:, cacheable_count: 0)
+            messages.each_with_index.map do |message, index|
+              cache = index < cacheable_count
               if message.tool_call?
-                format_tool_call_message(message, thinking: thinking)
+                format_tool_call_message(message, thinking:, cache:)
               elsif message.tool_result?
-                format_tool_result_message(message)
+                format_tool_result_message(message, cache:)
               else
                 {
                   role: anthropic_role(message.role),
-                  content: content_blocks(message.content, thinking: thinking, message: message)
+                  content: content_blocks(message.content, thinking:, message:, cache:)
                 }
               end
             end
@@ -127,12 +134,12 @@ module Legion
             role == :assistant ? 'assistant' : 'user'
           end
 
-          def content_blocks(content, thinking: false, message: nil)
+          def content_blocks(content, thinking: false, message: nil, cache: false)
             raw_blocks = raw_content(content)
             return with_thinking(raw_blocks, message, thinking) if raw_blocks
 
             blocks = []
-            blocks << text_block(content_text(content)) unless content_text(content).to_s.empty?
+            blocks << text_block(content_text(content), cache:) unless content_text(content).to_s.empty?
             blocks.concat(attachment_blocks(content)) if content.respond_to?(:attachments)
             with_thinking(blocks, message, thinking)
           end
@@ -149,8 +156,10 @@ module Legion
             content.to_s
           end
 
-          def text_block(text)
-            { type: 'text', text: text }
+          def text_block(text, cache: false)
+            { type: 'text', text: text }.tap do |block|
+              block[:cache_control] = { type: 'ephemeral' } if cache
+            end
           end
 
           def attachment_blocks(content)
@@ -175,30 +184,34 @@ module Legion
             thinking_block ? [thinking_block, *blocks] : blocks
           end
 
-          def format_tool_call_message(message, thinking:)
-            blocks = content_blocks(message.content, thinking: thinking, message: message)
-            message.tool_calls.each_value { |tool_call| blocks << tool_use_block(tool_call) }
+          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:) }
             { role: 'assistant', content: blocks }
           end
 
-          def tool_use_block(tool_call)
+          def tool_use_block(tool_call, cache: false)
             {
               type: 'tool_use',
               id: tool_call.id,
               name: tool_call.name,
-              input: tool_call.arguments
-            }
+              input: tool_call.arguments,
+              cache_control: { type: 'ephemeral' }
+            }.tap do |block|
+              block.delete(:cache_control) unless cache
+            end
           end
 
-          def format_tool_result_message(message)
+          def format_tool_result_message(message, cache: false)
             {
               role: 'user',
               content: [
                 {
                   type: 'tool_result',
                   tool_use_id: message.tool_call_id,
-                  content: content_blocks(message.content)
-                }
+                  content: content_blocks(message.content, cache:),
+                  cache_control: { type: 'ephemeral' }
+                }.tap { |block| block.delete(:cache_control) unless cache }
               ]
             }
           end
@@ -234,16 +247,20 @@ module Legion
             end
           end
 
-          def format_tools(tools)
+          def format_tools(tools, cache: false)
             return nil if tools.empty?
 
-            tools.values.map do |tool|
+            tool_array = tools.values.map do |tool|
               {
                 name: tool.name,
                 description: tool.description,
                 input_schema: tool_schema(tool)
               }
             end
+
+            tool_array.last[:cache_control] = { type: 'ephemeral' } if cache && tool_array.any?
+
+            tool_array
           end
 
           def tool_schema(tool)
@@ -287,7 +304,7 @@ module Legion
             normalized = normalized.dup
             normalized.delete(:strict)
             normalized.delete('strict')
-            { format: { type: 'json_schema', schema: normalized } }
+            { format: { type: 'json', schema: normalized } }
           end
 
           def parse_completion_response(response)
@@ -355,18 +372,13 @@ module Legion
             )
           end
 
-          def extract_streaming_tool_calls(data, delta_type)
+          def extract_streaming_tool_calls(data, _delta_type)
             content_block = data['content_block']
-            if content_block && content_block['type'] == 'tool_use'
-              { content_block['id'] => Legion::Extensions::Llm::ToolCall.new(
-                id: content_block['id'], name: content_block['name'], arguments: ''
-              ) }
-            elsif delta_type == 'input_json_delta'
-              partial = data.dig('delta', 'partial_json')
-              return nil unless partial
-
-              { nil => Legion::Extensions::Llm::ToolCall.new(id: nil, name: nil, arguments: partial) }
-            end
+            return nil unless content_block && content_block['type'] == 'tool_use'
+
+            { content_block['id'] => Legion::Extensions::Llm::ToolCall.new(
+              id: content_block['id'], name: content_block['name'], arguments: ''
+            ) }
           end
 
           def parse_tool_calls(content_blocks)
@@ -405,6 +417,10 @@ module Legion
             CONTEXT_WINDOWS.find { |prefix, _| model_id.start_with?(prefix) }&.last
           end
 
+          def model_detail(model_name)
+            fetch_model_detail(model_name)
+          end
+
           def fetch_model_detail(model_name)
             ctx = infer_context_window(model_name)
             ctx ? { context_window: ctx } : nil

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

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

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

@@ -24,7 +24,7 @@ module Legion
             instance: {
               default_model: 'claude-sonnet-4-6',
               endpoint: 'https://api.anthropic.com',
-              api_version: '2023-06-01',
+              api_version: '2023-10-16',
               default_max_tokens: 4096,
               tier: :frontier,
               transport: :http,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-anthropic
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.13
 platform: ruby
 authors:
 - LegionIO
@@ -97,6 +97,7 @@ files:
 - README.md
 - lex-llm-anthropic.gemspec
 - lib/legion/extensions/llm/anthropic.rb
+- lib/legion/extensions/llm/anthropic/actors/discovery_refresh.rb
 - lib/legion/extensions/llm/anthropic/actors/fleet_worker.rb
 - lib/legion/extensions/llm/anthropic/provider.rb
 - lib/legion/extensions/llm/anthropic/registry_event_builder.rb