lex-llm 0.8.0 → 0.8.5

data/spec/legion/extensions/llm/canonical/thinking/config_spec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../../conformance/conformance'
+
+RSpec.describe Legion::Extensions::Llm::Canonical::Thinking::Config do
+  subject(:config_class) { described_class }
+
+  let(:type_class) { described_class }
+  let(:auto_generated_members) { [] }
+  let(:type_source) do
+    { enabled: true, effort: 'high', budget: 4096, summary: :concise, metadata: { source: 'client' } }
+  end
+
+  it_behaves_like 'a canonical type'
+
+  it 'converts from a plain class to a Data with one name (04 §8)' do
+    expect(config_class).to be_a(Class)
+    expect(config_class.new(enabled: true, effort: 'low', budget: nil, summary: nil, metadata: {})).to be_a(config_class)
+  end
+
+  it 'normalizes symbol effort to String' do
+    config = config_class.build(effort: :low)
+    expect(config.effort).to eq('low')
+  end
+
+  it 'raises on a wrong-class effort' do
+    expect { config_class.build(effort: 3) }
+      .to raise_error(ArgumentError, /effort expected String, got Integer/)
+  end
+
+  describe 'enabled member' do
+    it 'defaults to true in .build' do
+      config = config_class.build
+      expect(config.enabled).to be(true)
+    end
+
+    it 'defaults to true in .from_hash when key absent' do
+      config = config_class.from_hash({})
+      expect(config.enabled).to be(true)
+    end
+
+    it 'accepts explicit true' do
+      config = config_class.build(enabled: true)
+      expect(config.enabled).to be(true)
+    end
+
+    it 'accepts explicit false' do
+      config = config_class.build(enabled: false)
+      expect(config.enabled).to be(false)
+    end
+
+    it 'rejects non-boolean in .new' do
+      expect { config_class.new(enabled: 'yes', effort: nil, budget: nil, summary: nil, metadata: {}) }
+        .to raise_error(ArgumentError, /enabled must be true or false/)
+    end
+
+    it 'rejects nil in .new (must be an explicit boolean)' do
+      expect { config_class.new(enabled: nil, effort: nil, budget: nil, summary: nil, metadata: {}) }
+        .to raise_error(ArgumentError, /enabled must be true or false/)
+    end
+
+    it 'enabled? returns the enabled member' do
+      expect(config_class.build(enabled: true).enabled?).to be(true)
+      expect(config_class.build(enabled: false).enabled?).to be(false)
+    end
+  end
+
+  describe 'H1/M4 — effort is a closed enum, validated in every constructor' do
+    it 'rejects an unrecognized effort in build, from_hash, and .new' do
+      expect { config_class.build(effort: 'banana') }
+        .to raise_error(ArgumentError, /Invalid effort: "banana"/)
+      expect { config_class.from_hash(effort: 'banana') }
+        .to raise_error(ArgumentError, /Invalid effort: "banana"/)
+      expect { config_class.new(enabled: true, effort: 'banana', budget: nil, summary: nil, metadata: {}) }
+        .to raise_error(ArgumentError, /Invalid effort: "banana"/)
+    end
+
+    it 'accepts the enum case-insensitively (symbol or string)' do
+      expect(config_class.build(effort: :HIGH).effort).to eq('high')
+      expect(config_class.new(enabled: true, effort: 'Medium', budget: nil, summary: nil, metadata: {}).effort).to eq('medium')
+    end
+
+    it 'accepts all six effort levels' do
+      %w[none low medium high xhigh max].each do |level|
+        expect(config_class.build(effort: level).effort).to eq(level)
+      end
+    end
+
+    it 'resolved_budget derives from the validated effort (no silent medium fallback)' do
+      expect(config_class.build(effort: 'low').resolved_budget).to eq(1024)
+      expect(config_class.build(effort: 'medium').resolved_budget).to eq(8192)
+      expect(config_class.build(effort: 'high').resolved_budget).to eq(16_384)
+      expect(config_class.build(effort: 'xhigh').resolved_budget).to eq(24_576)
+      expect(config_class.build(effort: 'max').resolved_budget).to eq(32_768)
+      expect(config_class.build(effort: 'none').resolved_budget).to be_nil
+      expect(config_class.build(budget: 123).resolved_budget).to eq(123)
+      expect(config_class.build(enabled: false).resolved_budget).to be_nil
+    end
+  end
+
+  describe 'budget validation' do
+    it 'accepts a positive integer' do
+      expect(config_class.build(budget: 1).budget).to eq(1)
+      expect(config_class.build(budget: 50_000).budget).to eq(50_000)
+    end
+
+    it 'accepts nil' do
+      expect(config_class.build(budget: nil).budget).to be_nil
+    end
+
+    it 'rejects zero' do
+      expect { config_class.build(budget: 0) }
+        .to raise_error(ArgumentError, /budget must be positive/)
+    end
+
+    it 'rejects negative integers' do
+      expect { config_class.build(budget: -1) }
+        .to raise_error(ArgumentError, /budget must be positive/)
+      expect { config_class.build(budget: -100) }
+        .to raise_error(ArgumentError, /budget must be positive/)
+    end
+
+    it 'rejects non-Integer types' do
+      expect { config_class.build(budget: 1.5) }
+        .to raise_error(ArgumentError, /budget expected Integer/)
+      expect { config_class.build(budget: '1024') }
+        .to raise_error(ArgumentError, /budget expected Integer/)
+    end
+  end
+
+  describe 'summary enum' do
+    it 'accepts nil (default)' do
+      expect(config_class.build(summary: nil).summary).to be_nil
+    end
+
+    it 'accepts :auto, :none, :concise, :detailed' do
+      %i[auto none concise detailed].each do |level|
+        expect(config_class.build(summary: level).summary).to eq(level)
+      end
+    end
+
+    it 'coerces string to symbol' do
+      expect(config_class.from_hash(summary: 'concise').summary).to eq(:concise)
+    end
+
+    it 'rejects invalid summary values' do
+      expect { config_class.build(summary: :verbose) }
+        .to raise_error(ArgumentError, /Invalid summary/)
+      expect { config_class.build(summary: :full) }
+        .to raise_error(ArgumentError, /Invalid summary/)
+    end
+
+    it 'rejects non-symbol/string types' do
+      expect { config_class.build(summary: 42) }
+        .to raise_error(ArgumentError, /summary expected Symbol/)
+    end
+  end
+
+  it 'keeps the effort<->budget SSOT conversions' do
+    expect(config_class.build(effort: 'low').resolved_budget).to eq(1024)
+    expect(config_class.build(effort: 'medium').resolved_budget).to eq(8192)
+    expect(config_class.build(effort: 'high').resolved_budget).to eq(16_384)
+    expect(config_class.build(effort: 'xhigh').resolved_budget).to eq(24_576)
+    expect(config_class.build(effort: 'max').resolved_budget).to eq(32_768)
+    expect(config_class.build(budget: 512).resolved_effort).to eq('low')
+    expect(config_class.build(budget: 1024).resolved_effort).to eq('low')
+    expect(config_class.build(budget: 8192).resolved_effort).to eq('medium')
+    expect(config_class.build(budget: 16_384).resolved_effort).to eq('high')
+    expect(config_class.build(budget: 24_576).resolved_effort).to eq('xhigh')
+    expect(config_class.build(budget: 32_768).resolved_effort).to eq('max')
+    expect(config_class.build(budget: 50_000).resolved_effort).to eq('max')
+  end
+
+  describe 'resolved_effort band boundaries' do
+    it 'maps budget at boundary to the correct effort level' do
+      # At the low boundary
+      expect(config_class.build(budget: 1024).resolved_effort).to eq('low')
+      # Just above low
+      expect(config_class.build(budget: 1025).resolved_effort).to eq('medium')
+      # At medium boundary
+      expect(config_class.build(budget: 8192).resolved_effort).to eq('medium')
+      # Just above medium
+      expect(config_class.build(budget: 8193).resolved_effort).to eq('high')
+      # At high boundary
+      expect(config_class.build(budget: 16_384).resolved_effort).to eq('high')
+      # Just above high
+      expect(config_class.build(budget: 16_385).resolved_effort).to eq('xhigh')
+      # At xhigh boundary
+      expect(config_class.build(budget: 24_576).resolved_effort).to eq('xhigh')
+      # Just above xhigh
+      expect(config_class.build(budget: 24_577).resolved_effort).to eq('max')
+    end
+
+    it 'returns nil when budget is nil (no fabrication)' do
+      expect(config_class.build.resolved_effort).to be_nil
+    end
+
+    it 'returns the supplied effort when both are set (no overwrite)' do
+      config = config_class.build(effort: 'low', budget: 30_000)
+      expect(config.resolved_effort).to eq('low')
+      expect(config.resolved_budget).to eq(30_000)
+    end
+  end
+
+  it 'to_h is faithful to what was set (no fabricated axis)' do
+    expect(config_class.build(effort: 'low').to_h).to eq(enabled: true, effort: 'low', metadata: {})
+    # enabled:false is explicit OFF signal — it IS set, so it appears in to_h
+    expect(config_class.build(enabled: false).to_h).to eq(enabled: false, metadata: {})
+  end
+
+  it 'to_h omits nil members (compact)' do
+    config = config_class.build(enabled: true, effort: 'high', budget: 4096, summary: :detailed)
+    expect(config.to_h).to eq(enabled: true, effort: 'high', budget: 4096, summary: :detailed, metadata: {})
+  end
+
+  it 'from_hash round-trips through to_h' do
+    original = config_class.build(enabled: true, effort: 'xhigh', budget: 24_576, summary: :auto)
+    rebuilt = config_class.from_hash(original.to_h)
+    expect(rebuilt).to eq(original)
+  end
+end

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

@@ -38,72 +38,4 @@ RSpec.describe Legion::Extensions::Llm::Canonical::Thinking do
       expect(round_tripped.signature).to eq('sig-1')
     end
   end
-
-  describe Legion::Extensions::Llm::Canonical::Thinking::Config do
-    subject(:config_class) { described_class }
-
-    let(:type_class) { described_class }
-    let(:auto_generated_members) { [] }
-    let(:type_source) do
-      { effort: 'high', budget: 4096, metadata: { source: 'client' } }
-    end
-
-    it_behaves_like 'a canonical type'
-
-    it 'converts from a plain class to a Data with one name (04 §8)' do
-      expect(config_class).to be_a(Class)
-      expect(config_class.new(effort: 'low', budget: nil, metadata: {})).to be_a(config_class)
-    end
-
-    it 'normalizes symbol effort to String' do
-      config = config_class.build(effort: :low)
-      expect(config.effort).to eq('low')
-    end
-
-    it 'raises on a wrong-class effort' do
-      expect { config_class.build(effort: 3) }
-        .to raise_error(ArgumentError, /effort expected String, got Integer/)
-    end
-
-    describe 'H1/M4 — effort is a closed enum, validated in every constructor' do
-      it 'rejects an unrecognized effort in build, from_hash, and .new' do
-        expect { config_class.build(effort: 'banana') }
-          .to raise_error(ArgumentError, /Invalid effort: "banana"/)
-        expect { config_class.from_hash(effort: 'banana') }
-          .to raise_error(ArgumentError, /Invalid effort: "banana"/)
-        expect { config_class.new(effort: 'banana') }
-          .to raise_error(ArgumentError, /Invalid effort: "banana"/)
-      end
-
-      it 'accepts the enum case-insensitively (symbol or string)' do
-        expect(config_class.build(effort: :HIGH).effort).to eq('high')
-        expect(config_class.new(effort: 'Medium').effort).to eq('medium')
-      end
-
-      it 'resolved_budget derives from the validated effort (no silent medium fallback)' do
-        expect(config_class.new(effort: 'low').resolved_budget).to eq(1024)
-        expect(config_class.build(budget: 123).resolved_budget).to eq(123)
-        expect(config_class.build.resolved_budget).to be_nil
-      end
-    end
-
-    it 'keeps the effort<->budget SSOT conversions' do
-      expect(config_class.build(effort: 'low').resolved_budget).to eq(1024)
-      expect(config_class.build(effort: 'medium').resolved_budget).to eq(8192)
-      expect(config_class.build(effort: 'high').resolved_budget).to eq(16_384)
-      expect(config_class.build(budget: 512).resolved_effort).to eq('low')
-      expect(config_class.build(budget: 8192).resolved_effort).to eq('medium')
-      expect(config_class.build(budget: 16_384).resolved_effort).to eq('high')
-    end
-
-    it 'is enabled only when an axis is set' do
-      expect(config_class.build(effort: 'low').enabled?).to be(true)
-      expect(config_class.build(budget: 1).enabled?).to be(true)
-      expect(config_class.build.enabled?).to be(false)
-    end
-
-    it 'to_h is faithful to what was set (no fabricated axis)' do
-      expect(config_class.build(effort: 'low').to_h).to eq(effort: 'low', metadata: {})
-    end
-  end
 end

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

@@ -10,7 +10,7 @@
 #
 # Usage:
 #   it_behaves_like 'a canonical client translator', MyClientTranslatorClass
-# rubocop:disable Lint/NonLocalExitFromIterator -- return guard is idiomatic in shared_example blocks
+# rubocop:disable-next Lint/NonLocalExitFromIterator -- return guard is idiomatic in shared_example blocks
 RSpec.shared_examples 'a canonical client translator' do |translator_class|
   let(:translator) { translator_class.new }
   let(:canonical) { Legion::Extensions::Llm::Canonical }
@@ -429,4 +429,3 @@ RSpec.shared_examples 'a canonical client translator' do |translator_class|
     end
   end
 end
-# rubocop:enable Lint/NonLocalExitFromIterator

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

@@ -21,7 +21,7 @@
       }
     },
     "params": { "max_tokens": 1024, "temperature": 0.5 },
-    "thinking": { "effort": "low", "budget": 1024 },
+    "thinking": { "enabled": true, "effort": "low", "budget": 1024 },
     "stream": false,
     "conversation_id": "conv_fleet_rt_001",
     "caller": { "type": "anthropic_messages", "client_id": "test_client" },

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

@@ -8,12 +8,12 @@
     }
   ],
   "thinking": {
+    "enabled": true,
     "effort": "high",
     "budget": 4096
   },
   "params": {
-    "max_tokens": 2048,
-    "max_thinking_tokens": 4096
+    "max_tokens": 2048
   },
   "stream": false
 }

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

@@ -9,7 +9,7 @@ require_relative 'ssot_contract_examples'
 # Kit self-test: the B/F/R shared examples run against a real Provider-derived
 # callable, the real Registry, and the real fleet responder/worker — proving
 # the examples provider gems will load are executable and meaningful.
-# rubocop:disable RSpec/DescribeClass, RSpec/MultipleMemoizedHelpers -- kit host
+# rubocop:disable-next RSpec/DescribeClass, RSpec/MultipleMemoizedHelpers -- kit host
 RSpec.describe 'SSOT v4 contract conformance kit' do
   include SsotRegistryHelpers
 
@@ -34,7 +34,7 @@ RSpec.describe 'SSOT v4 contract conformance kit' do
         Legion::Extensions::Llm::Canonical::Response.build(text: 'ok', model: model, stop_reason: :end_turn)
       end
 
-      # rubocop:disable Lint/UnusedMethodArgument -- model: mirrors the 0.8.0 callable contract
+      # rubocop:disable-next Lint/UnusedMethodArgument -- model: mirrors the 0.8.0 callable contract
       def stream_chat(messages, model: nil, tools: nil, **_contract, &block)
         enforce_canonical_messages!(messages)
         enforce_canonical_tools!(tools)
@@ -43,7 +43,6 @@ RSpec.describe 'SSOT v4 contract conformance kit' do
                                                                    usage: Legion::Extensions::Llm::Canonical::Usage.build(input_tokens: 1)))
         nil
       end
-      # rubocop:enable Lint/UnusedMethodArgument
 
       def count_tokens(messages:, **_contract)
         enforce_canonical_messages!(messages)
@@ -127,4 +126,3 @@ RSpec.describe 'SSOT v4 contract conformance kit' do
   it_behaves_like 'R4 — weight law (07 §4)'
   it_behaves_like 'R5 — callable lifecycle (07 §6)'
 end
-# rubocop:enable RSpec/DescribeClass, RSpec/MultipleMemoizedHelpers

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

@@ -44,10 +44,9 @@ RSpec.shared_examples 'B1 — central canonical enforcement (08 F2)' do
     end
 
     it "stream_chat rejects #{label} with a typed ArgumentError" do
-      # rubocop:disable Lint/EmptyBlock -- the block never runs: enforcement raises first
+      # rubocop:disable-next Lint/EmptyBlock -- the block never runs: enforcement raises first
       expect { callable.stream_chat(bad_messages, model: 'm') { |_c| } }
         .to raise_error(ArgumentError, /Canonical::Message/)
-      # rubocop:enable Lint/EmptyBlock
     end
 
     it "count_tokens rejects #{label} with a typed ArgumentError" do
@@ -121,9 +120,8 @@ RSpec.shared_examples 'B3 — operation preservation (PR #189 defect class)' do
       block&.call(CAN::Chunk.done(request_id: nil))
     end
 
-    # rubocop:disable Lint/EmptyBlock -- the block is the assertion target
+    # rubocop:disable-next Lint/EmptyBlock -- the block is the assertion target
     callable.stream_chat([CAN::Message.build(role: :user, content: 'hi')], model: 'm') { |_c| }
-    # rubocop:enable Lint/EmptyBlock
 
     expect(stream_invocations).to eq(1)
     expect(chat_invocations).to eq(0)

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'faraday/net_http'
+require_relative '../../../support/tls_endpoint'
+
+RSpec.describe Legion::Extensions::Llm::Connection do
+  around do |example|
+    saved = Legion::Settings.loader.settings[:extensions]
+    Legion::Settings.loader.settings[:extensions] = { llm: Legion::Extensions::Llm.default_settings }
+    example.run
+  ensure
+    if saved.nil?
+      Legion::Settings.loader.settings.delete(:extensions)
+    else
+      Legion::Settings.loader.settings[:extensions] = saved
+    end
+  end
+
+  { typhoeus: Faraday::ConnectionFailed, net_http: Faraday::SSLError }.each do |adapter, error_class|
+    context "with the #{adapter} adapter" do
+      let(:endpoint) { SpecSupport::TlsEndpoint.new }
+      let(:config) do
+        Legion::Extensions::Llm::Configuration.new.tap do |configuration|
+          configuration.logger = Logger.new(File::NULL)
+          configuration.max_retries = 0
+          configuration.request_timeout = 3
+        end
+      end
+      let(:provider) do
+        instance_double(Legion::Extensions::Llm::Provider,
+                        api_base: endpoint.url,
+                        headers: { 'Authorization' => 'Bearer tls-fixture' },
+                        parse_error: nil)
+      end
+      let(:connection) do
+        described_class.new(provider, config).tap do |client|
+          client.connection.builder.adapter(adapter)
+          client.connection.proxy = nil
+        end
+      end
+
+      after do
+        connection.close
+        endpoint.close
+      end
+
+      context 'with the default disabled verification' do
+        let(:endpoint) { SpecSupport::TlsEndpoint.new(subject_alt_name: 'DNS:wrong.example.test') }
+
+        it 'allows an authenticated request despite an untrusted and mismatched certificate' do
+          response = connection.get('/tls-check')
+          endpoint.finish
+
+          expect(response.status).to eq(200)
+          expect(response.body).to eq('status' => 'ok')
+          expect(endpoint.requests.one? { |request| request.match?(/^authorization: Bearer tls-fixture\r?$/i) }).to be(true)
+        end
+      end
+
+      context 'when TLS verification is enabled in Legion settings' do
+        before do
+          Legion::Settings.loader.settings[:extensions][:llm][:ssl][:verify] = true
+        end
+
+        it 'rejects an untrusted certificate before sending an authenticated HTTP request' do
+          expect { connection.get('/tls-check') }.to raise_error(error_class)
+          endpoint.finish
+
+          expect(endpoint.requests).to be_empty
+        end
+
+        it 'accepts a matching certificate through an explicitly trusted custom CA' do
+          connection.connection.ssl.ca_file = endpoint.ca_file.path
+
+          response = connection.get('/tls-check')
+          endpoint.finish
+
+          expect(response.status).to eq(200)
+          expect(response.body).to eq('status' => 'ok')
+          expect(endpoint.requests.one? { |request| request.match?(/^authorization: Bearer tls-fixture\r?$/i) }).to be(true)
+        end
+      end
+
+      context 'when TLS verification is enabled for a trusted wrong-host certificate' do
+        let(:endpoint) { SpecSupport::TlsEndpoint.new(subject_alt_name: 'DNS:wrong.example.test') }
+
+        before do
+          Legion::Settings.loader.settings[:extensions][:llm][:ssl][:verify] = true
+        end
+
+        it 'rejects the peer before sending an authenticated HTTP request' do
+          connection.connection.ssl.ca_file = endpoint.ca_file.path
+
+          expect { connection.get('/tls-check') }.to raise_error(error_class)
+          endpoint.finish
+
+          expect(endpoint.requests).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -247,7 +247,12 @@ RSpec.describe Legion::Extensions::Llm::CredentialSources do
     end
 
     it 'returns false when port is closed' do
-      expect(mod.socket_open?('127.0.0.1', 39_999, timeout: 0.05)).to be false
+      socket = Socket.new(:INET, :STREAM)
+      socket.bind(Socket.sockaddr_in(0, '127.0.0.1'))
+
+      expect(mod.socket_open?('127.0.0.1', socket.local_address.ip_port, timeout: 0.05)).to be false
+    ensure
+      socket&.close
     end
 
     it 'returns false when connection is refused' do
@@ -260,12 +265,16 @@ RSpec.describe Legion::Extensions::Llm::CredentialSources do
       expect(mod.socket_open?('192.0.2.1', 80, timeout: 0.05)).to be false
     end
 
-    it 'uses 0.1 second default timeout' do
-      server = TCPServer.new('127.0.0.1', 0)
-      port = server.addr[1]
-      expect(mod.socket_open?('127.0.0.1', port, timeout: 0.1)).to be true
-    ensure
-      server&.close
+    it 'returns false when an asynchronous connection completes with an error' do
+      socket_error = Socket::Option.int(Socket::AF_INET, Socket::SOL_SOCKET, Socket::SO_ERROR, Errno::ECONNREFUSED::Errno)
+      fake_sock = instance_double(Socket, setsockopt: nil, wait_writable: true, getsockopt: socket_error, close: nil)
+      allow(Socket).to receive(:new).and_return(fake_sock)
+      allow(fake_sock).to receive(:connect_nonblock).and_invoke(
+        ->(*) { raise IO::EINPROGRESSWaitWritable },
+        ->(*) { 0 }
+      )
+
+      expect(mod.socket_open?('192.0.2.1', 80, timeout: 0.05)).to be false
     end
   end
 

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-# rubocop:disable RSpec/DescribeClass
+# rubocop:disable-next RSpec/DescribeClass
 RSpec.describe 'LLM fleet message envelopes' do
   let(:protocol) { Legion::Extensions::Llm::Fleet::Protocol }
   let(:channel_class) do
@@ -408,4 +408,3 @@ RSpec.describe 'LLM fleet message envelopes' do
     end
   end
 end
-# rubocop:enable RSpec/DescribeClass

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-# rubocop:disable RSpec/DescribeClass
+# rubocop:disable-next RSpec/DescribeClass
 RSpec.describe 'lex-llm.gemspec' do
   subject(:gemspec) { Gem::Specification.load(File.expand_path('../../../../lex-llm.gemspec', __dir__)) }
 
@@ -22,4 +22,3 @@ RSpec.describe 'lex-llm.gemspec' do
     expect(gemspec.name).to eq('lex-llm')
   end
 end
-# rubocop:enable RSpec/DescribeClass

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

@@ -49,6 +49,29 @@ RSpec.describe Legion::Extensions::Llm::Provider::OpenAICompatible do
     expect(payload[:messages]).to eq([{ role: 'assistant', content: "internal\n</thinking>\n\nHello" }])
   end
 
+  describe 'reasoning_effort transposition (canonical Thinking::Config -> OpenAI wire)' do
+    def payload_for(thinking)
+      provider.send(:render_payload, [], tools: {}, model: model_id, stream: false,
+                                         schema: nil, thinking: thinking, tool_prefs: nil, params: nil)
+    end
+
+    it 'passes an explicit effort through' do
+      expect(payload_for(canonical::Thinking::Config.build(effort: 'high'))[:reasoning_effort]).to eq('high')
+    end
+
+    it 'derives effort from a budget-only config so it is never dropped' do
+      expect(payload_for(canonical::Thinking::Config.build(budget: 8192))[:reasoning_effort]).to eq('medium')
+    end
+
+    it 'omits reasoning_effort when thinking is explicitly disabled' do
+      expect(payload_for(canonical::Thinking::Config.build(enabled: false))).not_to have_key(:reasoning_effort)
+    end
+
+    it 'omits reasoning_effort when there is no thinking' do
+      expect(payload_for(nil)).not_to have_key(:reasoning_effort)
+    end
+  end
+
   it 'renders content block arrays in the OpenAI wire shape' do
     message = canonical::Message.build(
       role: :user,

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

@@ -201,9 +201,8 @@ RSpec.describe Legion::Extensions::Llm::Provider do
       it 'accepts Hash<name, Canonical::ToolDefinition> through chat and stream_chat' do
         expect(provider.chat([], model: 'test-model', tools: { get_weather: tool })).to eq('ok')
         expect do
-          # rubocop:disable Lint/EmptyBlock -- the streamed chunk is consumed by the stub
+          # rubocop:disable-next Lint/EmptyBlock -- the streamed chunk is consumed by the stub
           provider.stream_chat([], model: 'test-model', tools: { get_weather: tool }) { |_c| }
-          # rubocop:enable Lint/EmptyBlock
         end.not_to raise_error
       end