lex-llm 0.5.0 → 0.5.3

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
@@ -589,4 +610,35 @@ RSpec.describe Legion::Extensions::Llm::Provider do
       end
     end
   end
+
+  describe '#model_detail_cache_key' do
+    let(:provider_class) do
+      Class.new(described_class) do
+        def api_base = 'https://test.invalid'
+
+        def self.slug = 'testprov'
+      end
+    end
+
+    let(:provider) do
+      provider_class.new({ request_timeout: 30, max_retries: 0, retry_interval: 0,
+                           retry_backoff_factor: 0, retry_interval_randomness: 0 })
+    end
+
+    it 'includes the model-detail cache schema version in the key' do
+      key = provider.send(:model_detail_cache_key, 'test-model')
+      expect(key).to include("schema#{described_class::MODEL_DETAIL_CACHE_SCHEMA_VERSION}")
+      expect(key).to include('schema2')
+    end
+
+    it 'changes the key when the schema version constant changes' do
+      key_v2 = provider.send(:model_detail_cache_key, 'test-model')
+
+      stub_const("#{described_class}::MODEL_DETAIL_CACHE_SCHEMA_VERSION", 3)
+
+      key_v3 = provider.send(:model_detail_cache_key, 'test-model')
+      expect(key_v3).not_to eq(key_v2)
+      expect(key_v3).to include('schema3')
+    end
+  end
 end

data/spec/legion/extensions/llm/routing/model_offering_spec.rb

@@ -219,4 +219,62 @@ RSpec.describe Legion::Extensions::Llm::Routing::ModelOffering do
       limits: { context_window: 32_768, max_output_tokens: 8192 }
     )
   end
+
+  describe 'capability_sources' do
+    it 'accepts and exposes capability source metadata' do
+      sourced = described_class.new(
+        provider_family: :vllm,
+        provider_instance: :apollo,
+        model: 'gemma-4-12b-it',
+        capabilities: %i[streaming tools],
+        capability_sources: {
+          streaming: { value: true, source: :provider_envelope },
+          tools: { value: true, source: :instance_override },
+          embeddings: { value: false, source: :default_false }
+        }
+      )
+
+      expect(sourced.capabilities).to include(:streaming, :tools)
+      expect(sourced.capability_sources[:tools]).to eq(value: true, source: :instance_override)
+      expect(sourced.capability_sources[:embeddings]).to eq(value: false, source: :default_false)
+    end
+
+    it 'includes capability_sources in to_h' do
+      sourced = described_class.new(
+        provider_family: :vllm,
+        provider_instance: :apollo,
+        model: 'gemma-4-12b-it',
+        capabilities: %i[streaming],
+        capability_sources: {
+          streaming: { value: true, source: :provider_envelope }
+        }
+      )
+
+      expect(sourced.to_h[:capability_sources]).to eq(
+        streaming: { value: true, source: :provider_envelope }
+      )
+    end
+
+    it 'normalizes string-keyed capability sources' do
+      sourced = described_class.new(
+        provider_family: :vllm,
+        model: 'test',
+        capability_sources: {
+          'streaming' => { 'value' => true, 'source' => 'provider_envelope' }
+        }
+      )
+
+      expect(sourced.capability_sources[:streaming]).to eq(value: true, source: :provider_envelope)
+    end
+
+    it 'defaults to empty hash when not provided' do
+      plain = described_class.new(
+        provider_family: :ollama,
+        model: 'test',
+        capabilities: %i[streaming]
+      )
+
+      expect(plain.capability_sources).to eq({})
+    end
+  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

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

@@ -98,6 +98,15 @@ RSpec.describe Legion::Extensions::Llm::Streaming do
         .to raise_error(Legion::Extensions::Llm::ServerError, /Provider error.*The model is currently overloaded/)
     end
 
+    it 'raises UnauthorizedError for partial 401 streaming responses' do
+      buffer = +''
+      auth_env = Struct.new(:status).new(401)
+      truncated_chunk = '{"error":{"message":"Unauthorized'
+
+      expect { test_obj.send(:handle_failed_response, truncated_chunk, buffer, auth_env) }
+        .to raise_error(Legion::Extensions::Llm::UnauthorizedError, /Unauthorized/)
+    end
+
     it 'raises ServerError with generic message when no partial message is extractable and env cannot buffer' do
       buffer = +''
       partial_chunk = '{"error":{'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.3
 platform: ruby
 authors:
 - LegionIO
@@ -270,7 +270,9 @@ 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/capability_policy.rb
 - lib/legion/extensions/llm/chat.rb
 - lib/legion/extensions/llm/chunk.rb
 - lib/legion/extensions/llm/configuration.rb
@@ -353,7 +355,9 @@ 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/capability_policy_spec.rb
 - spec/legion/extensions/llm/configuration_spec.rb
 - spec/legion/extensions/llm/conformance/client_translator_examples.rb
 - spec/legion/extensions/llm/conformance/conformance.rb
@@ -364,11 +368,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 +385,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 +402,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