lex-llm 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ab0a51687719efbd7f048be70ff4ba57b6d81fafddfcaefb2f0d78f5f3721ae
-  data.tar.gz: 49e57ce1c99330d956cc92b6c6a75a283f078f5e0b8fb036ae7aad9579caccd0
+  metadata.gz: 2aef21677943bb1b621d6defad35f76e3ca8195ea971b172e7924c7b83774f62
+  data.tar.gz: 8a46fdb9ead39ffb08335e019e4623844ad91de4af1cb30960802a39ecf75ab0
 SHA512:
-  metadata.gz: 8d8fcea6f732dd4c5dfcd713024796a640941d18c8ef90f3c5b5ca0b3fcbc0094942f2cadabbdd78669ecabce8cd76f893488a92f15ec70c21ebec865fb0a531
-  data.tar.gz: 4a062635e491cb84b60117b1c28520a8fc5bb4d0775609ed1104639e549114c2a373e68461833008a234e33d7ac14a5fe1292cc2f37fe37b0f00818387cc4851
+  metadata.gz: 6909cc6018428bde9983ab3cf001d31f87cd9a90c7c58571e6daa3041dbe25962f610ea37b79a1abf1094385feea37e6f2d466c2131ed41e939e7c4da8ac3980
+  data.tar.gz: 5c2b52d64916c8b169a49dc3459ca1aac9c4af6f148865ae190368d364754dce3e35865bf3cfa525ce431cd0bfe0f940240c989b20f5a4be0f26c9cba4574471

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.5.1 - 2026-06-12
+
+### Fixed
+- **ToolDefinition constants** — Move `OBJECT_SCHEMA_KEYWORDS` and `COMPOSITE_SCHEMA_KEYWORDS` out of `Data.define` block to satisfy `Lint/ConstantDefinitionInBlock`.
+- **ToolSchema documentation** — Add top-level module documentation comment.
+- **Conformance spec cleanup** — Remove unused block argument from shared examples, fix duplicate describe block and context wording in tool_definition_spec.
+- **RuboCop clean** — Zero offenses across 140 files.
+
 ## 0.5.0 - 2026-06-10
 
 ### Added

data/lib/legion/extensions/llm/canonical/message.rb

@@ -72,11 +72,24 @@ module Legion
               h[:content] = ContentBlock.from_hash(content)
             end
 
-            # Parse tool calls if they're an array of hashes
+            # Parse tool calls — Array is canonical; Hash is legacy lex-llm format (name → ToolCall)
             tool_calls = h[:tool_calls]
-            if tool_calls.is_a?(Array)
+            if tool_calls.is_a?(Hash)
+              h[:tool_calls] = tool_calls.values.map do |tc|
+                next tc if tc.is_a?(ToolCall)
+
+                raw = tc.respond_to?(:to_h) ? tc.to_h : tc
+                ToolCall.from_hash(raw)
+              end
+            elsif tool_calls.is_a?(Array)
               h[:tool_calls] = tool_calls.map do |tc|
-                tc.is_a?(ToolCall) ? tc : ToolCall.from_hash(tc)
+                next tc if tc.is_a?(ToolCall)
+
+                if tc.is_a?(Hash)
+                  ToolCall.from_hash(tc)
+                else
+                  ToolCall.from_hash(tc.respond_to?(:to_h) ? tc.to_h : tc)
+                end
               end
             end
 

data/lib/legion/extensions/llm/canonical/tool_definition.rb

@@ -5,16 +5,33 @@ module Legion
     module Llm
       module Canonical
         TOOL_NAME_MAX_LENGTH = 64
+        OBJECT_SCHEMA_KEYWORDS    = %i[properties required additionalProperties].freeze
+        COMPOSITE_SCHEMA_KEYWORDS = %i[oneOf anyOf allOf enum $ref $defs definitions].freeze
 
         # Canonical tool definition.
         # Ports field vocabulary from Legion::LLM::Types::ToolDefinition.
         ToolDefinition = ::Data.define(:name, :description, :parameters, :source) do
+          def self.normalize_parameters(parameters)
+            empty = { type: 'object', properties: {} }
+            return empty if parameters.nil?
+
+            schema = if parameters.respond_to?(:transform_keys)
+                       parameters.transform_keys { |k| k.respond_to?(:to_sym) ? k.to_sym : k }
+                     end
+            return empty if schema.nil? || schema.empty?
+            return schema if schema.key?(:type)
+            return schema.merge(type: 'object') if OBJECT_SCHEMA_KEYWORDS.any? { |k| schema.key?(k) }
+            return schema if COMPOSITE_SCHEMA_KEYWORDS.any? { |k| schema.key?(k) }
+
+            { type: 'object', properties: schema }
+          end
+
           # Build from keyword args (primary constructor).
           def self.build(name:, description: '', parameters: nil, source: nil)
             new(
               sanitize_tool_name(name),
               description.to_s,
-              parameters || {},
+              normalize_parameters(parameters),
               source || { type: :builtin }
             )
           end
@@ -58,6 +75,14 @@ module Legion
             name.empty? ? 'tool' : name
           end
 
+          def params_schema
+            parameters
+          end
+
+          def input_schema
+            parameters
+          end
+
           # Serialize to a Hash for AMQP/fleet/wire transport.
           def to_h
             {

data/lib/legion/extensions/llm/canonical/tool_schema.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Canonical
+        # Extracts and normalizes tool schemas from heterogeneous sources.
+        module ToolSchema
+          EMPTY_OBJECT = { type: 'object', properties: {} }.freeze
+
+          module_function
+
+          def extract(tool)
+            raw = raw_schema(tool)
+            ToolDefinition.normalize_parameters(raw)
+          end
+
+          def raw_schema(tool)
+            return nil if tool.nil?
+            return tool.params_schema if tool.respond_to?(:params_schema) && tool.params_schema
+            return tool.parameters if tool.respond_to?(:parameters) && tool.parameters
+
+            return unless tool.respond_to?(:[])
+
+            tool[:parameters] || tool['parameters'] || tool[:input_schema] || tool['input_schema'] ||
+              tool[:params_schema] || tool['params_schema']
+          end
+
+          def tool_name(tool)
+            return tool.name if tool.respond_to?(:name) && !tool.is_a?(Hash)
+            return tool[:name] || tool['name'] if tool.respond_to?(:[])
+
+            'unknown'
+          end
+
+          def tool_description(tool)
+            return tool.description if tool.respond_to?(:description) && !tool.is_a?(Hash)
+            return (tool[:description] || tool['description'] || '').to_s if tool.respond_to?(:[])
+
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/canonical/usage.rb

@@ -30,6 +30,12 @@ module Legion
             h[:cache_write_tokens] ||= h.delete(:cache_creation) || h.delete(:cache_write)
             h[:thinking_tokens] ||= h.delete(:thinking) || h.delete(:reasoning)
 
+            # Extract nested details (OpenAI prompt_tokens_details / input_tokens_details)
+            h[:cache_read_tokens] ||= dig_nested(h, :prompt_tokens_details, :cached_tokens) ||
+                                      dig_nested(h, :input_tokens_details, :cached_tokens)
+            h[:thinking_tokens] ||= dig_nested(h, :completion_tokens_details, :reasoning_tokens) ||
+                                    dig_nested(h, :output_tokens_details, :reasoning_tokens)
+
             # Extract units (non-token extension point — G20b)
             units = h.delete(:units) || {}
 
@@ -43,6 +49,13 @@ module Legion
             )
           end
 
+          def self.dig_nested(hash, details_key, value_key)
+            details = hash[details_key]
+            return nil unless details.is_a?(Hash)
+
+            details[value_key] || details[value_key.to_s]
+          end
+
           # Serialize to a Hash for AMQP/fleet/wire transport.
           def to_h
             super.compact

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

@@ -5,6 +5,7 @@ require_relative 'canonical/usage'
 require_relative 'canonical/params'
 require_relative 'canonical/content_block'
 require_relative 'canonical/tool_definition'
+require_relative 'canonical/tool_schema'
 require_relative 'canonical/tool_call'
 require_relative 'canonical/message'
 require_relative 'canonical/request'

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

@@ -54,6 +54,8 @@ module Legion
 
       # Faraday middleware that maps provider-specific API errors to Legion::Extensions::Llm errors.
       class ErrorMiddleware < Faraday::Middleware
+        extend Legion::Logging::Helper
+
         STREAM_ERROR_BODY_KEY = :legion_llm_stream_error_body
 
         def initialize(app, options = {})

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

@@ -76,7 +76,12 @@ module Legion
           def format_openai_tool_calls(tool_calls)
             return nil unless tool_calls&.any?
 
-            tool_calls.values.map do |tool_call|
+            # Array is the canonical shape (per canonical/message.rb); Hash
+            # is the legacy lex-llm shape (id => ToolCall). Both flow through
+            # this renderer depending on caller.
+            calls = tool_calls.is_a?(Hash) ? tool_calls.values : Array(tool_calls)
+
+            calls.map do |tool_call|
               {
                 id: tool_call.id,
                 type: 'function',
@@ -92,16 +97,12 @@ module Legion
             return nil if tools.empty?
 
             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'] || '')
-              tool_params = tool.respond_to?(:params_schema) ? tool.params_schema : (tool[:parameters] || tool['parameters'] || {})
               {
                 type: 'function',
                 function: {
-                  name: tool_name,
-                  description: tool_desc,
-                  parameters: tool_params || { type: 'object', properties: {} }
+                  name: Canonical::ToolSchema.tool_name(tool),
+                  description: Canonical::ToolSchema.tool_description(tool),
+                  parameters: Canonical::ToolSchema.extract(tool)
                 }
               }
             end

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

@@ -137,7 +137,7 @@ module Legion
           parse_list_models_response response, slug, capabilities
         end
 
-        def discover_offerings(live: false, **filters)
+        def discover_offerings(live: false, raise_on_unreachable: false, **filters)
           return filter_cached_offerings(Array(@cached_offerings), filters) unless live
 
           provider_health = health(live:)
@@ -148,8 +148,10 @@ module Legion
             offering_from_model(model, health: provider_health)
           end
           @cached_offerings
-        rescue Faraday::ConnectionFailed => e
+        rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
           log.warn("[#{slug}] instance=#{provider_instance_id} unreachable: #{e.message}")
+          raise if raise_on_unreachable
+
           []
         end
 
@@ -224,9 +226,16 @@ module Legion
         end
 
         def cache_enabled?
-          return false unless config.respond_to?(:llm_cache_enabled)
+          explicit = config.llm_cache_enabled if config.respond_to?(:llm_cache_enabled)
+
+          unless explicit.nil?
+            log.debug { "[#{slug}] cache_enabled? source=per_provider value=#{explicit}" }
+            return explicit == true
+          end
 
-          config.llm_cache_enabled == true
+          global = global_prompt_caching_enabled?
+          log.debug { "[#{slug}] cache_enabled? source=global value=#{global}" }
+          global
         end
 
         def cache_control_prefix_tokens
@@ -528,6 +537,14 @@ module Legion
 
         private
 
+        def global_prompt_caching_enabled?
+          return false unless defined?(Legion::Settings)
+
+          Legion::Settings.dig(:llm, :prompt_caching, :enabled) == true
+        rescue StandardError
+          false
+        end
+
         def model_detail_cache_key(model_name)
           tier = offering_tier
           instance_key = cache_instance_key

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

@@ -11,10 +11,19 @@ module Legion
           embed: [%i[keyreq text], %i[keyreq model]],
           image: [%i[keyreq prompt], %i[keyreq model]],
           list_models: [%i[key live], %i[keyrest filters]],
-          discover_offerings: [%i[key live], %i[keyrest filters]],
+          discover_offerings: [%i[key live], %i[key raise_on_unreachable], %i[keyrest filters]],
           health: [%i[key live]],
           count_tokens: [%i[keyreq messages], %i[keyreq model], %i[key params]]
         }.freeze
+
+        # Tools passed to chat/stream_chat must support Canonical::ToolDefinition objects.
+        # Providers must not crash on Data.define instances (not Hashes).
+        TOOL_SUPPORT_CONTRACT = <<~DOC
+          - chat and stream_chat accept keyword `tools:` (Hash<name, tool_object>)
+          - tools may be Canonical::ToolDefinition, Hash, or legacy Lex::Llm::Tool
+          - Renderers must use Canonical::ToolSchema.extract(tool) for schema access
+          - discover_offerings(live: true, raise_on_unreachable: true) raises on transport failure
+        DOC
       end
     end
   end

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

@@ -57,6 +57,27 @@ module Legion
           )
         end
 
+        # Flush any text still held in the untagged-preamble buffer as a final
+        # streamed chunk. Without this, short responses that match the
+        # untagged-reasoning heuristic (e.g. starting with "I", "The", "Let me")
+        # and never hit a double newline are buffered for the entire stream and
+        # the caller's block never receives a single delta.
+        def flush_pending_chunk
+          return nil if @untagged_preamble_buffer.empty?
+
+          @last_content_delta = +''
+          @last_thinking_delta = +''
+          flush_pending_untagged_preamble_into_deltas
+          return nil if @last_content_delta.empty? && @last_thinking_delta.empty?
+
+          Chunk.new(
+            role: :assistant,
+            content: @last_content_delta.empty? ? nil : @last_content_delta,
+            thinking: @last_thinking_delta.empty? ? nil : Thinking.build(text: @last_thinking_delta),
+            model_id: model_id
+          )
+        end
+
         def to_message(response)
           flush_pending_untagged_preamble
 
@@ -233,6 +254,24 @@ module Legion
           @untagged_preamble_pending = false
         end
 
+        # Same as flush_pending_untagged_preamble, but also records the flushed
+        # text in the per-chunk delta accumulators so flush_pending_chunk can
+        # surface it to the streaming block.
+        def flush_pending_untagged_preamble_into_deltas
+          content, thinking = Responses::ThinkingExtractor.extract_untagged_preamble(@untagged_preamble_buffer)
+          if thinking
+            @content << content
+            @last_content_delta << content
+            @thinking_text << thinking
+            @last_thinking_delta << thinking
+          else
+            @content << @untagged_preamble_buffer
+            @last_content_delta << @untagged_preamble_buffer
+          end
+          @untagged_preamble_buffer = +''
+          @untagged_preamble_pending = false
+        end
+
         def append_thinking_from_chunk(chunk)
           thinking = chunk.thinking
           return unless thinking

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

@@ -24,6 +24,11 @@ module Legion
             end
           end
 
+          # Release any text held by the untagged-preamble heuristic so short
+          # responses still stream at least one delta to the caller.
+          final_chunk = accumulator.flush_pending_chunk
+          block&.call(final_chunk) if final_chunk
+
           message = accumulator.to_message(response)
           log.debug { "Stream completed: #{message.content}" }
           message
@@ -31,6 +36,8 @@ module Legion
 
         def build_stream_callback(accumulator, block)
           proc do |chunk|
+            next unless chunk
+
             accumulator.add chunk
             filtered = accumulator.filtered_chunk(chunk)
             block.call(filtered) if filtered
@@ -39,7 +46,10 @@ module Legion
 
         def handle_stream(&block)
           build_on_data_handler do |data|
-            block.call(build_chunk(data)) if data.is_a?(Hash)
+            next unless data.is_a?(Hash)
+
+            chunk = build_chunk(data)
+            block.call(chunk) if chunk
           end
         end
 
@@ -183,7 +193,7 @@ module Legion
         def build_stream_error_response(parsed_data, env, status)
           error_status = status || env&.status || 500
 
-          if faraday_1?
+          if faraday_1? || env.nil?
             Struct.new(:body, :status).new(parsed_data, error_status)
           else
             env.merge(body: parsed_data, status: error_status)

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Llm
-      VERSION = '0.5.0'
+      VERSION = '0.5.1'
     end
   end
 end

data/spec/legion/extensions/llm/canonical/tool_definition_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Legion::Extensions::Llm::Canonical::ToolDefinition do
 
       expect(tool.name).to eq('search')
       expect(tool.description).to eq('Search the web')
-      expect(tool.parameters).to eq({})
+      expect(tool.parameters).to eq(type: 'object', properties: {})
       expect(tool.source).to eq({ type: :builtin })
     end
 
@@ -113,7 +113,7 @@ RSpec.describe Legion::Extensions::Llm::Canonical::ToolDefinition do
       entry = {
         name: 'custom',
         description: 'Custom tool',
-        parameters: {},
+        parameters: { type: 'object', properties: { name: { type: 'string' } } },
         extension: 'custom-ext'
       }
       tool = described_class.from_registry_entry(entry)
@@ -160,6 +160,53 @@ RSpec.describe Legion::Extensions::Llm::Canonical::ToolDefinition do
     end
   end
 
+  describe '.normalize_parameters' do
+    it 'injects type: object when a schema has properties but no type' do
+      schema = { properties: { task: { type: 'string' } }, required: ['task'] }
+      result = described_class.normalize_parameters(schema)
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(task: { type: 'string' })
+      expect(result[:required]).to eq(['task'])
+    end
+
+    it 'passes schemas with an explicit type through unchanged' do
+      schema = { type: 'object', properties: { a: { type: 'string' } } }
+      expect(described_class.normalize_parameters(schema)).to eq(schema)
+    end
+
+    it 'wraps a bare property map under type:object/properties' do
+      expect(described_class.normalize_parameters(location: { type: 'string' }))
+        .to eq(type: 'object', properties: { location: { type: 'string' } })
+    end
+
+    it 'returns an empty object schema for nil/empty' do
+      expect(described_class.normalize_parameters(nil)).to eq(type: 'object', properties: {})
+      expect(described_class.normalize_parameters({})).to eq(type: 'object', properties: {})
+    end
+
+    it 'symbolizes top-level string keys' do
+      result = described_class.normalize_parameters('properties' => { 'a' => { 'type' => 'string' } })
+      expect(result[:type]).to eq('object')
+      expect(result).to have_key(:properties)
+    end
+
+    it 'leaves composite schemas (oneOf etc.) without forcing type' do
+      schema = { oneOf: [{ type: 'string' }, { type: 'integer' }] }
+      expect(described_class.normalize_parameters(schema)).to eq(schema)
+    end
+
+    it 'normalizes parameters at construction via .build' do
+      td = described_class.build(name: 'multi_agent_v1',
+                                 parameters: { properties: { task: { type: 'string' } } })
+      expect(td.parameters[:type]).to eq('object')
+    end
+
+    it 'normalizes nil parameters to empty object schema via .build' do
+      td = described_class.build(name: 'bare_tool')
+      expect(td.parameters).to eq(type: 'object', properties: {})
+    end
+  end
+
   describe 'round-trip' do
     it 'preserves values through from_hash/to_h' do
       original = { name: 'search', description: 'Search', parameters: { type: 'object' } }

data/spec/legion/extensions/llm/canonical/tool_schema_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Llm::Canonical::ToolSchema do
+  let(:full_schema) { { type: 'object', properties: { city: { type: 'string' } }, required: ['city'] } }
+  let(:canonical_tool) do
+    Legion::Extensions::Llm::Canonical::ToolDefinition.build(
+      name: 'get_weather', description: 'Weather lookup', parameters: full_schema
+    )
+  end
+
+  describe '.extract' do
+    it 'extracts from a Canonical::ToolDefinition' do
+      result = described_class.extract(canonical_tool)
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'extracts from a Hash with :parameters' do
+      result = described_class.extract({ parameters: full_schema })
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'extracts from a Hash with :input_schema' do
+      result = described_class.extract({ input_schema: full_schema })
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'extracts from a Hash with :params_schema' do
+      result = described_class.extract({ params_schema: full_schema })
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'extracts from an object responding to params_schema' do
+      tool = Struct.new(:params_schema).new(full_schema)
+      result = described_class.extract(tool)
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'returns empty object schema for nil' do
+      expect(described_class.extract(nil)).to eq(type: 'object', properties: {})
+    end
+
+    it 'returns empty object schema for empty hash' do
+      expect(described_class.extract({})).to eq(type: 'object', properties: {})
+    end
+  end
+
+  describe '.tool_name' do
+    it 'gets name from Canonical::ToolDefinition' do
+      expect(described_class.tool_name(canonical_tool)).to eq('get_weather')
+    end
+
+    it 'gets name from Hash' do
+      expect(described_class.tool_name({ name: 'foo' })).to eq('foo')
+    end
+  end
+
+  describe '.tool_description' do
+    it 'gets description from Canonical::ToolDefinition' do
+      expect(described_class.tool_description(canonical_tool)).to eq('Weather lookup')
+    end
+
+    it 'gets description from Hash' do
+      expect(described_class.tool_description({ description: 'bar' })).to eq('bar')
+    end
+  end
+
+  describe 'ToolDefinition compatibility readers' do
+    it 'params_schema returns normalized parameters' do
+      expect(canonical_tool.params_schema).to eq(full_schema)
+    end
+
+    it 'input_schema aliases params_schema' do
+      expect(canonical_tool.input_schema).to eq(canonical_tool.params_schema)
+    end
+  end
+end

data/spec/legion/extensions/llm/canonical/usage_spec.rb

@@ -114,6 +114,46 @@ RSpec.describe Legion::Extensions::Llm::Canonical::Usage do
     end
   end
 
+  describe 'OpenAI nested details extraction' do
+    it 'extracts cached_tokens from prompt_tokens_details (Chat API)' do
+      usage = described_class.from_hash(
+        prompt_tokens: 1000,
+        completion_tokens: 200,
+        prompt_tokens_details: { cached_tokens: 800 },
+        completion_tokens_details: { reasoning_tokens: 50 }
+      )
+
+      expect(usage.input_tokens).to eq(1000)
+      expect(usage.output_tokens).to eq(200)
+      expect(usage.cache_read_tokens).to eq(800)
+      expect(usage.thinking_tokens).to eq(50)
+    end
+
+    it 'extracts cached_tokens from input_tokens_details (Responses API)' do
+      usage = described_class.from_hash(
+        input_tokens: 500,
+        output_tokens: 100,
+        input_tokens_details: { cached_tokens: 400 },
+        output_tokens_details: { reasoning_tokens: 30 }
+      )
+
+      expect(usage.input_tokens).to eq(500)
+      expect(usage.output_tokens).to eq(100)
+      expect(usage.cache_read_tokens).to eq(400)
+      expect(usage.thinking_tokens).to eq(30)
+    end
+
+    it 'prefers top-level cache_read_tokens over nested details' do
+      usage = described_class.from_hash(
+        input_tokens: 500,
+        cache_read_tokens: 300,
+        prompt_tokens_details: { cached_tokens: 400 }
+      )
+
+      expect(usage.cache_read_tokens).to eq(300)
+    end
+  end
+
   describe 'round-trip' do
     it 'preserves values through from_hash/to_h' do
       original = { input_tokens: 100, output_tokens: 50, cache_read_tokens: 10 }

data/spec/legion/extensions/llm/conformance/client_translator_examples.rb

@@ -265,5 +265,168 @@ RSpec.shared_examples 'a canonical client translator' do |translator_class|
       end
     end
   end
+
+  # G24 — execution-proxy response contract.
+  #
+  # When a server-executed LegionIO tool resolves before the canonical response
+  # is returned, the tool_call carries `:result` and a server-tool source
+  # (registry/special/extension/mcp). Client translators MUST surface that
+  # exchange as a completed, NON-actionable item — the client must not try to
+  # re-execute it. Per format:
+  #
+  #   * Claude /v1/messages — server_tool_use + server_tool_result content
+  #     blocks (NOT plain tool_use). stop_reason end_turn once all server
+  #     results are present.
+  #   * Codex /v1/responses — completed function_call items (or message items)
+  #     showing name+arguments+result, status 'completed' (NOT 'in_progress'
+  #     or 'requires_action'). The response status is 'completed', not
+  #     'requires_action'.
+  #   * Codex /v1/chat/completions — finish_reason 'stop' (not 'tool_calls')
+  #     when only server tools were called and they all have results; the
+  #     server tool exchange does not appear as actionable tool_calls.
+  #
+  # Translators declare their family via `g24_format` (one of :claude_messages,
+  # :openai_responses, :openai_chat) so the shared examples can pick the right
+  # shape assertions. Translators that don't implement g24_format are skipped.
+  describe 'G24 execution-proxy contract' do
+    let(:canonical_resp) do
+      canonical::Response.from_hash(conformance.fixture_symbolized('canonical_server_tool_use_response'))
+    end
+
+    let(:format) do
+      next nil unless translator.respond_to?(:g24_format)
+
+      translator.g24_format
+    end
+
+    context 'with a server-executed tool result in the canonical response' do
+      it 'surfaces the server tool name in the formatted response' do
+        next if format.nil?
+
+        formatted = translator.format_response(canonical_resp)
+        formatted_str = formatted.to_s
+        expect(formatted_str).to include('legion_list_all_tools')
+      end
+
+      it 'surfaces the server tool result text in the formatted response' do
+        next if format.nil?
+
+        formatted = translator.format_response(canonical_resp)
+        formatted_str = formatted.to_s
+        expect(formatted_str).to include('legion_list_all_tools, legion_apollo_search')
+      end
+
+      it 'never surfaces server-executed tools as actionable items', :aggregate_failures do
+        next if format.nil?
+
+        formatted = translator.format_response(canonical_resp)
+
+        case format
+        when :claude_messages
+          # Server-side tools must appear as server_tool_use, never tool_use.
+          # The G24 contract says the model must know the call happened AND
+          # the client must not re-execute, so server_tool_use+server_tool_result
+          # are the only shape — plain tool_use would put the client in a
+          # tool-loop trying to fulfill an already-resolved exchange.
+          types = (formatted[:content] || formatted['content']).map { |b| b[:type] || b['type'] }
+          expect(types).to include('server_tool_use')
+          expect(types).to include('server_tool_result')
+          expect(types).not_to include('tool_use')
+
+          stop_reason = formatted[:stop_reason] || formatted['stop_reason']
+          expect(stop_reason).to eq('end_turn')
+
+          server_use = (formatted[:content] || formatted['content']).find do |b|
+            (b[:type] || b['type']).to_s == 'server_tool_use'
+          end
+          expect(server_use[:name] || server_use['name']).to eq('legion_list_all_tools')
+
+          server_result = (formatted[:content] || formatted['content']).find do |b|
+            (b[:type] || b['type']).to_s == 'server_tool_result'
+          end
+          result_text = (server_result[:content] || server_result['content']).first
+          expect(result_text[:text] || result_text['text']).to include('legion_list_all_tools')
+        when :openai_responses
+          status = formatted[:status] || formatted['status']
+          expect(status).to eq('completed')
+
+          output = formatted[:output] || formatted['output']
+          actionable = output.select do |item|
+            type = (item[:type] || item['type']).to_s
+            status_str = (item[:status] || item['status']).to_s
+            type == 'function_call' && status_str != 'completed'
+          end
+          expect(actionable).to be_empty,
+                                "found actionable function_call items for server tools: #{actionable.inspect}"
+
+          # action_required is the legacy requires-action surface — server
+          # tools must never end up there.
+          action_required = formatted[:action_required] || formatted['action_required']
+          expect(action_required).to be_nil
+        when :openai_chat
+          choice = (formatted[:choices] || formatted['choices']).first
+          finish_reason = choice[:finish_reason] || choice['finish_reason']
+          expect(finish_reason).to eq('stop')
+
+          message = choice[:message] || choice['message']
+          actionable = (message[:tool_calls] || message['tool_calls'] || []).reject do |tc|
+            (tc[:status] || tc['status']).to_s == 'completed'
+          end
+          expect(actionable).to be_empty,
+                                "found actionable tool_calls for server tools: #{actionable.inspect}"
+        else
+          raise "unknown G24 format: #{format.inspect}"
+        end
+      end
+    end
+
+    it 'formats the streaming tool_call_delta with the registry source' do
+      next if format.nil?
+
+      # The streaming tool_call_delta carries the resolved server_tool result.
+      # We don't assert the per-chunk SSE encoding here (that's the route's
+      # event emitter contract); we assert format_chunk doesn't drop the call
+      # and the source flows through.
+      stream_fixture = conformance.fixture('canonical_streaming_server_tool_chunks')
+      tool_chunk = stream_fixture['chunks'].find do |c|
+        c['type'] == 'tool_call_delta' && c.dig('tool_call', 'result')
+      end
+      expect(tool_chunk).not_to be_nil
+
+      chunk = canonical::Chunk.from_hash(tool_chunk)
+      formatted = translator.format_chunk(chunk)
+
+      next if formatted.nil?
+
+      # Format-specific minimum: the tool name is reachable. Streaming
+      # shape per format is asserted in the matrix harness; here we only
+      # require that the server-tool name survives chunk formatting.
+      expect(formatted.to_s).to include('legion_list_all_tools')
+    end
+
+    it 'parses a continuation request with a prior server-executed exchange losslessly' do
+      next if format.nil?
+      next unless translator.respond_to?(:format_request)
+
+      # Each translator round-trips its own format. We render the canonical
+      # continuation with format_request (when available) then re-parse —
+      # the prior server tool exchange must survive intact.
+      continuation_body = conformance.fixture_symbolized('canonical_server_tool_continuation_request')
+      canonical_req = canonical::Request.from_hash(continuation_body)
+      formatted_body = translator.format_request(canonical_req)
+      next if formatted_body.nil?
+
+      parsed = translator.parse_request(formatted_body, {})
+      expect(parsed).to be_a(canonical::Request)
+
+      # The assistant tool_call and the tool result both survive the cycle.
+      roles = parsed.messages.map { |m| m.role.to_sym }
+      expect(roles).to include(:assistant)
+      expect(roles).to include(:tool)
+
+      tool_msg = parsed.messages.find { |m| m.role.to_sym == :tool }
+      expect(tool_msg.content.to_s).to include('legion_list_all_tools')
+    end
+  end
 end
 # rubocop:enable Lint/NonLocalExitFromIterator

data/spec/legion/extensions/llm/conformance/fixtures/canonical_server_tool_continuation_request.json

@@ -0,0 +1,43 @@
+{
+  "description": "G24 round-trip — when a client sends back a history that contains a completed server-side exchange (Claude: server_tool_use+server_tool_result blocks; Codex: completed function_call+function_call_output items), the client translator must parse them into canonical messages losslessly so the next turn rendering still attributes the call to the assistant and its result to the tool role. Tools array is empty because the server-side exchange is already closed; this request is just continuing the conversation.",
+  "id": "req_g24_continuation_001",
+  "messages": [
+    {
+      "role": "user",
+      "content": "what legionio tools do you have available?"
+    },
+    {
+      "role": "assistant",
+      "content": "I called the legion_list_all_tools tool.",
+      "tool_calls": [
+        {
+          "id": "call_legion_001",
+          "name": "legion_list_all_tools",
+          "arguments": {"filter": "all"},
+          "source": "registry",
+          "status": "success",
+          "result": "tools: legion_list_all_tools, legion_apollo_search"
+        }
+      ]
+    },
+    {
+      "role": "tool",
+      "tool_call_id": "call_legion_001",
+      "content": "tools: legion_list_all_tools, legion_apollo_search"
+    },
+    {
+      "role": "user",
+      "content": "thanks — anything else?"
+    }
+  ],
+  "system": null,
+  "tools": null,
+  "params": null,
+  "thinking": null,
+  "stream": false,
+  "conversation_id": "conv_g24_001",
+  "routing": {},
+  "metadata": {
+    "g24": "continuation"
+  }
+}

data/spec/legion/extensions/llm/conformance/fixtures/canonical_server_tool_use_response.json

@@ -0,0 +1,29 @@
+{
+  "description": "G24 — server-executed LegionIO tool. The provider returned tool_use, the executor ran the tool registry-side, and the canonical response carries both the call AND its result so client translators can surface it as a completed exchange (Claude: server_tool_use+server_tool_result, Codex: completed function_call+function_call_output non-actionable). stop_reason is end_turn because the server-side exchange is closed by the time the canonical response is built.",
+  "text": "I called the legion_list_all_tools tool and here is the list.",
+  "thinking": null,
+  "tool_calls": [
+    {
+      "id": "call_legion_001",
+      "exchange_id": "exch_legion_001",
+      "name": "legion_list_all_tools",
+      "arguments": {
+        "filter": "all"
+      },
+      "source": "registry",
+      "status": "success",
+      "result": "tools: legion_list_all_tools, legion_apollo_search, legion_runner_dispatch",
+      "duration_ms": 42
+    }
+  ],
+  "usage": {
+    "input_tokens": 50,
+    "output_tokens": 22
+  },
+  "stop_reason": "end_turn",
+  "model": "test-model-1",
+  "routing": {},
+  "metadata": {
+    "g24": true
+  }
+}

data/spec/legion/extensions/llm/conformance/fixtures/canonical_streaming_server_tool_chunks.json

@@ -0,0 +1,52 @@
+{
+  "description": "G24 — streaming sequence for a server-executed LegionIO tool. The server-side exchange streams as tool_call_delta(s) (with the result attached on close) followed by trailing text from round-2. Client translators must turn this into completed (non-actionable) blocks: Claude server_tool_use+server_tool_result blocks, Codex completed function_call items with results visible.",
+  "request_id": "req_stream_legion_001",
+  "chunks": [
+    {
+      "request_id": "req_stream_legion_001",
+      "index": 0,
+      "type": "tool_call_delta",
+      "tool_call": {
+        "id": "call_legion_stream_001",
+        "name": "legion_list_all_tools",
+        "arguments": {"filter": "all"},
+        "source": "registry",
+        "status": "running"
+      }
+    },
+    {
+      "request_id": "req_stream_legion_001",
+      "index": 0,
+      "type": "tool_call_delta",
+      "tool_call": {
+        "id": "call_legion_stream_001",
+        "name": "legion_list_all_tools",
+        "arguments": {"filter": "all"},
+        "source": "registry",
+        "status": "success",
+        "result": "tools: legion_list_all_tools, legion_apollo_search"
+      }
+    },
+    {
+      "request_id": "req_stream_legion_001",
+      "index": 1,
+      "type": "text_delta",
+      "delta": "I called the "
+    },
+    {
+      "request_id": "req_stream_legion_001",
+      "index": 1,
+      "type": "text_delta",
+      "delta": "legion_list_all_tools tool."
+    },
+    {
+      "request_id": "req_stream_legion_001",
+      "type": "done",
+      "stop_reason": "end_turn",
+      "usage": {
+        "input_tokens": 50,
+        "output_tokens": 25
+      }
+    }
+  ]
+}

data/spec/legion/extensions/llm/conformance/provider_tool_rendering_examples.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Shared examples for provider tool rendering conformance.
+# Include in any provider gem that renders tools to prove it handles
+# canonical ToolDefinition objects, Hashes, and schemas without double-wrap.
+#
+# Usage in provider specs:
+#   it_behaves_like 'canonical tool rendering', described_class.new(...)
+#
+RSpec.shared_examples 'canonical tool rendering' do # rubocop:disable RSpec/MultipleMemoizedHelpers
+  let(:full_schema) { { type: 'object', properties: { city: { type: 'string' } }, required: ['city'] } }
+
+  let(:canonical_tool) do
+    Legion::Extensions::Llm::Canonical::ToolDefinition.build(
+      name: 'get_weather',
+      description: 'Weather lookup',
+      parameters: full_schema
+    )
+  end
+
+  let(:hash_tool_parameters) do
+    { name: 'get_weather', description: 'Weather lookup', parameters: full_schema }
+  end
+
+  let(:hash_tool_input_schema) do
+    { name: 'get_weather', description: 'Weather lookup', input_schema: full_schema }
+  end
+
+  let(:hash_tool_params_schema) do
+    { name: 'get_weather', description: 'Weather lookup', params_schema: full_schema }
+  end
+
+  let(:tools_map) { { 'get_weather' => canonical_tool } }
+
+  describe 'canonical tool rendering' do # rubocop:disable RSpec/MultipleMemoizedHelpers
+    it 'accepts Canonical::ToolDefinition without raising' do
+      expect { render_tools(tools_map) }.not_to raise_error
+    end
+
+    it 'renders schema with top-level type: object' do
+      rendered = render_tools(tools_map)
+      schema = extract_rendered_schema(rendered)
+      expect(schema[:type] || schema['type']).to eq('object')
+    end
+
+    it 'renders properties without double-wrap' do
+      rendered = render_tools(tools_map)
+      schema = extract_rendered_schema(rendered)
+      props = schema[:properties] || schema['properties']
+      expect(props).not_to have_key(:type)
+      expect(props).not_to have_key('type')
+      expect(props).to have_key(:city).or have_key('city')
+    end
+
+    it 'renders Hash tools with :parameters identically to canonical' do
+      map = { 'get_weather' => hash_tool_parameters }
+      rendered = render_tools(map)
+      schema = extract_rendered_schema(rendered)
+      expect(schema[:type] || schema['type']).to eq('object')
+      expect(schema[:properties] || schema['properties']).to have_key(:city).or have_key('city')
+    end
+
+    it 'renders Hash tools with :input_schema identically' do
+      map = { 'get_weather' => hash_tool_input_schema }
+      rendered = render_tools(map)
+      schema = extract_rendered_schema(rendered)
+      expect(schema[:type] || schema['type']).to eq('object')
+    end
+
+    it 'renders Hash tools with :params_schema identically' do
+      map = { 'get_weather' => hash_tool_params_schema }
+      rendered = render_tools(map)
+      schema = extract_rendered_schema(rendered)
+      expect(schema[:type] || schema['type']).to eq('object')
+    end
+  end
+end

data/spec/legion/extensions/llm/provider/open_ai_compatible_tool_calls_array_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/llm/provider/open_ai_compatible'
+require 'legion/extensions/llm/message'
+require 'legion/extensions/llm/tool_call'
+
+# Failing-test for the legionio-e2e claude/openai legionio_tool_injection
+# regression. After the LexLLMAdapter#normalize_message_tool_calls fix
+# (legion-llm 4317d56), the adapter now emits Array<ToolCall> on the
+# assistant message — which is the historical canonical shape per
+# canonical/message.rb:75 ("Array is canonical; Hash is legacy lex-llm
+# format (name → ToolCall)"). The OpenAI-compatible HTTP payload renderer
+# missed that update and still calls `.values` on tool_calls, so live
+# requests now blow up with:
+#
+#   undefined method 'values' for an instance of Array
+#
+# (captured at
+#  legionio-e2e/results/claude/openai_legionio_tool_injection_returns_response_containing_legionio_tool_references_response.json)
+#
+# The bedrock provider (format_invoke_model_assistant) and the
+# lex-llm-openai canonical translator (translator.rb:290) already handle
+# both shapes via `tool_calls.is_a?(Hash) ? .values : Array(...)`. This
+# spec pins the same shape-tolerance for OpenAICompatible.
+RSpec.describe Legion::Extensions::Llm::Provider::OpenAICompatible do
+  let(:host_class) do
+    Class.new do
+      include Legion::Extensions::Llm::Provider::OpenAICompatible
+
+      # Expose the otherwise-private renderer so we can test it directly
+      # without booting a full provider stack.
+      public :format_openai_tool_calls
+    end
+  end
+
+  let(:host) { host_class.new }
+
+  let(:tool_call) do
+    Legion::Extensions::Llm::ToolCall.new(
+      id: 'call_001',
+      name: 'legion_list_all_tools',
+      arguments: { 'filter' => 'all' }
+    )
+  end
+
+  it 'renders an Array<ToolCall> (the post-canonical shape)' do
+    rendered = host.format_openai_tool_calls([tool_call])
+    expect(rendered).to be_an(Array)
+    expect(rendered.size).to eq(1)
+    expect(rendered.first[:id]).to eq('call_001')
+    expect(rendered.first[:type]).to eq('function')
+    expect(rendered.first[:function][:name]).to eq('legion_list_all_tools')
+  end
+
+  it 'renders a Hash<id, ToolCall> (legacy lex-llm shape) without regression' do
+    rendered = host.format_openai_tool_calls({ call_id: tool_call })
+    expect(rendered).to be_an(Array)
+    expect(rendered.size).to eq(1)
+    expect(rendered.first[:function][:name]).to eq('legion_list_all_tools')
+  end
+
+  it 'returns nil when tool_calls is nil or empty' do
+    expect(host.format_openai_tool_calls(nil)).to be_nil
+    expect(host.format_openai_tool_calls([])).to be_nil
+    expect(host.format_openai_tool_calls({})).to be_nil
+  end
+end

data/spec/legion/extensions/llm/provider_spec.rb

@@ -542,25 +542,46 @@ RSpec.describe Legion::Extensions::Llm::Provider do
     end
 
     describe '#cache_enabled?' do
-      it 'returns true when llm_cache_enabled is true in config' do
+      it 'returns true when llm_cache_enabled is true in config (per-provider explicit)' do
         Legion::Extensions::Llm.config.llm_cache_enabled = true
         provider = provider_class.new(Legion::Extensions::Llm.config)
 
         expect(provider.cache_enabled?).to be true
       end
 
-      it 'returns false when llm_cache_enabled is false in config' do
+      it 'returns false when llm_cache_enabled is false in config (per-provider explicit)' do
         Legion::Extensions::Llm.config.llm_cache_enabled = false
         provider = provider_class.new(Legion::Extensions::Llm.config)
 
         expect(provider.cache_enabled?).to be false
       end
 
-      it 'returns false when llm_cache_enabled is not set on config' do
+      it 'falls through to global prompt_caching.enabled when config has no llm_cache_enabled' do
         config = { request_timeout: 30, max_retries: 0, retry_interval: 0, retry_backoff_factor: 0,
                    retry_interval_randomness: 0 }
         provider = provider_class.new(config)
 
+        Legion::Settings.loader.settings[:llm] ||= {}
+        Legion::Settings.loader.settings[:llm][:prompt_caching] = { enabled: true }
+        expect(provider.cache_enabled?).to be true
+      end
+
+      it 'returns false when global prompt_caching.enabled is false and no per-provider setting' do
+        config = { request_timeout: 30, max_retries: 0, retry_interval: 0, retry_backoff_factor: 0,
+                   retry_interval_randomness: 0 }
+        provider = provider_class.new(config)
+
+        Legion::Settings.loader.settings[:llm] ||= {}
+        Legion::Settings.loader.settings[:llm][:prompt_caching] = { enabled: false }
+        expect(provider.cache_enabled?).to be false
+      end
+
+      it 'per-provider setting overrides global when both present' do
+        Legion::Extensions::Llm.config.llm_cache_enabled = false
+        provider = provider_class.new(Legion::Extensions::Llm.config)
+
+        Legion::Settings.loader.settings[:llm] ||= {}
+        Legion::Settings.loader.settings[:llm][:prompt_caching] = { enabled: true }
         expect(provider.cache_enabled?).to be false
       end
     end

data/spec/legion/extensions/llm/stream_accumulator_spec.rb

@@ -100,4 +100,56 @@ RSpec.describe Legion::Extensions::Llm::StreamAccumulator do
       expect(message.thinking).to be_nil
     end
   end
+
+  describe '#filtered_chunk' do
+    it 'returns a chunk for a plain text delta' do
+      accumulator = described_class.new
+      chunk = Legion::Extensions::Llm::Chunk.new(role: :assistant, content: 'Hello', model_id: 'm')
+
+      accumulator.add(chunk)
+      filtered = accumulator.filtered_chunk(chunk)
+
+      expect(filtered).not_to be_nil
+      expect(filtered.content.to_s).to eq('Hello')
+    end
+  end
+
+  describe '#flush_pending_chunk' do
+    it 'returns nil when nothing is buffered' do
+      accumulator = described_class.new
+      chunk = Legion::Extensions::Llm::Chunk.new(role: :assistant, content: 'Hello', model_id: 'm')
+      accumulator.add(chunk)
+
+      expect(accumulator.flush_pending_chunk).to be_nil
+    end
+
+    it 'releases text held by the untagged-preamble heuristic as a final delta' do
+      accumulator = described_class.new
+      deltas = []
+      ['I can help', ' with that.'].each do |text|
+        chunk = Legion::Extensions::Llm::Chunk.new(role: :assistant, content: text, model_id: 'm')
+        accumulator.add(chunk)
+        filtered = accumulator.filtered_chunk(chunk)
+        deltas << filtered.content.to_s if filtered
+      end
+
+      final = accumulator.flush_pending_chunk
+      deltas << final.content.to_s if final
+      message = accumulator.to_message(nil)
+
+      expect(deltas.join).to eq('I can help with that.')
+      expect(message.content).to eq('I can help with that.')
+    end
+
+    it 'does not double-append flushed text in to_message' do
+      accumulator = described_class.new
+      chunk = Legion::Extensions::Llm::Chunk.new(role: :assistant, content: 'The answer', model_id: 'm')
+      accumulator.add(chunk)
+
+      accumulator.flush_pending_chunk
+      message = accumulator.to_message(nil)
+
+      expect(message.content).to eq('The answer')
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - LegionIO
@@ -270,6 +270,7 @@ files:
 - lib/legion/extensions/llm/canonical/thinking.rb
 - lib/legion/extensions/llm/canonical/tool_call.rb
 - lib/legion/extensions/llm/canonical/tool_definition.rb
+- lib/legion/extensions/llm/canonical/tool_schema.rb
 - lib/legion/extensions/llm/canonical/usage.rb
 - lib/legion/extensions/llm/chat.rb
 - lib/legion/extensions/llm/chunk.rb
@@ -353,6 +354,7 @@ files:
 - spec/legion/extensions/llm/canonical/thinking_spec.rb
 - spec/legion/extensions/llm/canonical/tool_call_spec.rb
 - spec/legion/extensions/llm/canonical/tool_definition_spec.rb
+- spec/legion/extensions/llm/canonical/tool_schema_spec.rb
 - spec/legion/extensions/llm/canonical/usage_spec.rb
 - spec/legion/extensions/llm/configuration_spec.rb
 - spec/legion/extensions/llm/conformance/client_translator_examples.rb
@@ -364,11 +366,14 @@ files:
 - spec/legion/extensions/llm/conformance/fixtures/canonical_fleet_round_trip.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_metering_audit_events.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_params_mapping_request.json
+- spec/legion/extensions/llm/conformance/fixtures/canonical_server_tool_continuation_request.json
+- spec/legion/extensions/llm/conformance/fixtures/canonical_server_tool_use_response.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_simple_text_request.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_simple_text_response.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_stop_reason_matrix.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_streaming_accumulated_response.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_streaming_error_chunks.json
+- spec/legion/extensions/llm/conformance/fixtures/canonical_streaming_server_tool_chunks.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_streaming_text_chunks.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_streaming_thinking_chunks.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_streaming_tool_call_chunks.json
@@ -378,6 +383,7 @@ files:
 - spec/legion/extensions/llm/conformance/fixtures/canonical_tool_results_continuation_request.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_tool_use_response.json
 - spec/legion/extensions/llm/conformance/fixtures/canonical_tools_request.json
+- spec/legion/extensions/llm/conformance/provider_tool_rendering_examples.rb
 - spec/legion/extensions/llm/conformance/provider_translator_examples.rb
 - spec/legion/extensions/llm/connection_logging_spec.rb
 - spec/legion/extensions/llm/connection_retry_spec.rb
@@ -394,6 +400,7 @@ files:
 - spec/legion/extensions/llm/model/info_spec.rb
 - spec/legion/extensions/llm/models_spec.rb
 - spec/legion/extensions/llm/provider/open_ai_compatible_spec.rb
+- spec/legion/extensions/llm/provider/open_ai_compatible_tool_calls_array_spec.rb
 - spec/legion/extensions/llm/provider_contract_spec.rb
 - spec/legion/extensions/llm/provider_settings_spec.rb
 - spec/legion/extensions/llm/provider_spec.rb