lex-llm 0.7.6 → 0.8.4

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

@@ -2,27 +2,10 @@
 
 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.
+# Regression pin for the legionio-e2e claude/openai legionio_tool_injection
+# defect: the renderer must handle Array<Canonical::ToolCall> (the canonical
+# shape). 0.8.0: the legacy Hash shape is deleted (O03a/L4 — Array only).
 RSpec.describe Legion::Extensions::Llm::Provider::OpenAICompatible do
   let(:host_class) do
     Class.new do
@@ -37,32 +20,25 @@ RSpec.describe Legion::Extensions::Llm::Provider::OpenAICompatible do
   let(:host) { host_class.new }
 
   let(:tool_call) do
-    Legion::Extensions::Llm::ToolCall.new(
-      id: 'call_001',
+    Legion::Extensions::Llm::Canonical::ToolCall.build(
       name: 'legion_list_all_tools',
+      id: 'call_001',
       arguments: { 'filter' => 'all' }
     )
   end
 
-  it 'renders an Array<ToolCall> (the post-canonical shape)' do
+  it 'renders an Array<Canonical::ToolCall>' 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')
+    expect(Legion::JSON.parse(rendered.first[:function][:arguments])).to eq(filter: 'all')
   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_contract_spec.rb

@@ -10,22 +10,19 @@ RSpec.describe Legion::Extensions::Llm::ProviderContract do
       def self.configuration_requirements = []
       def self.local? = false
       def self.remote? = true
-      def self.assume_models_exist? = false
 
       def ensure_configured! = nil
       def api_base = 'http://example.invalid'
       def models_url = '/v1/models'
-      def parse_list_models_response(*) = []
     end
   end
 
-  it 'requires canonical keyword provider methods' do
+  it 'requires the 0.8.0 provider method signatures' do
     expected = {
-      chat: [%i[keyreq messages], %i[keyreq model]],
-      stream_chat: [%i[keyreq messages], %i[keyreq model]],
+      chat: [%i[req messages], %i[keyreq model]],
+      stream_chat: [%i[req messages], %i[keyreq model]],
       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]],
       health: [%i[key live]],
       count_tokens: [%i[keyreq messages], %i[keyreq model], %i[key params]]
@@ -36,13 +33,12 @@ RSpec.describe Legion::Extensions::Llm::ProviderContract do
       required_parameters.each do |required_parameter|
         expect(parameters).to include(required_parameter), "#{method_name} missing #{required_parameter.inspect}"
       end
-      expect(parameters).not_to include(%i[req messages])
       expect(parameters).not_to include(%i[req text])
       expect(parameters).not_to include(%i[req prompt])
     end
   end
 
-  it 'rejects positional canonical arguments' do
+  it 'rejects non-canonical message input and positional artifact arguments' do
     provider = provider_class.new(
       request_timeout: 30,
       max_retries: 0,
@@ -51,20 +47,19 @@ RSpec.describe Legion::Extensions::Llm::ProviderContract do
       retry_interval_randomness: 0
     )
 
-    expect { provider.chat([], model: 'model') }.to raise_error(ArgumentError)
-    expect { provider.stream_chat([], model: 'model') }.to raise_error(ArgumentError)
+    expect { provider.chat(['not canonical'], model: 'model') }.to raise_error(ArgumentError, /Canonical::Message/)
+    expect { provider.stream_chat([42], model: 'model') }.to raise_error(ArgumentError, /Canonical::Message/)
+    expect { provider.count_tokens(messages: ['nope'], model: 'model') }.to raise_error(ArgumentError, /Canonical::Message/)
     expect { provider.embed('text', model: 'model') }.to raise_error(ArgumentError)
     expect { provider.image('prompt', model: 'model') }.to raise_error(ArgumentError)
-    expect { provider.count_tokens([], model: 'model') }.to raise_error(ArgumentError)
   end
 
-  it 'keeps REQUIRED_SIGNATURES as exactly the eight-entry reflection baseline' do
+  it 'keeps REQUIRED_SIGNATURES as exactly the seven-entry reflection baseline' do
     expect(described_class::REQUIRED_SIGNATURES).to eq(
-      chat: [%i[keyreq messages], %i[keyreq model]],
-      stream_chat: [%i[keyreq messages], %i[keyreq model]],
+      chat: [%i[req messages], %i[keyreq model]],
+      stream_chat: [%i[req messages], %i[keyreq model]],
       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[key raise_on_unreachable], %i[keyrest filters]],
       health: [%i[key live]],
       count_tokens: [%i[keyreq messages], %i[keyreq model], %i[key params]]

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

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'support/ssot_registry_helpers'
 
 RSpec.describe Legion::Extensions::Llm::Provider do
+  include SsotRegistryHelpers
+
   describe 'Hash config support' do
     let(:provider_class) do
       Class.new(described_class) do
@@ -100,38 +103,19 @@ RSpec.describe Legion::Extensions::Llm::Provider do
   end
 
   describe 'canonical provider contract' do
-    let(:model) do
-      Legion::Extensions::Llm::Model::Info.new(
-        id: 'test-model',
-        provider: :contract,
-        instance: :primary,
-        capabilities: %i[completion streaming tools],
-        context_length: 8192,
-        metadata: { max_output_tokens: 2048 }
-      )
-    end
-
     let(:provider_class) do
-      model_info = model
       Class.new(described_class) do
         def self.name = 'Provider'
 
         define_method(:api_base) { 'https://contract.invalid' }
         define_method(:models_url) { '/v1/models' }
-        attr_reader :list_model_calls
-
-        define_method(:list_models) do |live: false, **filters|
-          @list_model_calls ||= []
-          @list_model_calls << { live: live, filters: filters }
-          [model_info]
-        end
 
         def render_payload(_messages, **)
           {}
         end
 
         def parse_completion_response(_response)
-          Legion::Extensions::Llm::Message.new(role: :assistant, content: 'ok')
+          Legion::Extensions::Llm::Canonical::Response.build(text: 'ok')
         end
       end
     end
@@ -143,12 +127,12 @@ RSpec.describe Legion::Extensions::Llm::Provider do
                            instance_id: :primary })
     end
 
-    it 'exposes a canonical chat alias over complete' do
+    it 'exposes a canonical chat alias over complete (0.8.0 signature — O4 temperature in Params)' do
       allow(provider).to receive(:complete).and_return('ok')
 
-      expect(provider.chat(messages: [], model: model)).to eq('ok')
+      expect(provider.chat([], model: 'test-model')).to eq('ok')
       expect(provider).to have_received(:complete).with(
-        [], tools: [], temperature: nil, model: model, params: {}, headers: {},
+        [], tools: [], model: 'test-model', params: nil, headers: {},
             schema: nil, thinking: nil, tool_prefs: nil
       )
     end
@@ -157,73 +141,85 @@ RSpec.describe Legion::Extensions::Llm::Provider do
       seen = []
       allow(provider).to receive(:complete) { |_messages, **_opts, &block| block.call('chunk') }
 
-      provider.stream_chat(messages: [], model: model) { |chunk| seen << chunk }
+      provider.stream_chat([], model: 'test-model') { |chunk| seen << chunk }
 
       expect(seen).to eq(['chunk'])
     end
 
-    it 'converts live list_models results into model offerings' do
-      offerings = provider.discover_offerings(live: true)
-      offering = offerings.first
-
-      expect(offerings.size).to eq(1)
-      expect(offering.provider_family).to eq(:provider)
-      expect(offering.provider_instance).to eq(:primary)
-      expect(offering.model).to eq('test-model')
-      expect(offering.usage_type).to eq(:inference)
-      expect(offering.capabilities).to include(:completion, :streaming, :tools)
-      expect(offering.context_window).to eq(8192)
-    end
-
-    it 'publishes every discovered model before policy filtering removes blocked models' do
-      blocked_model = Legion::Extensions::Llm::Model::Info.new(
-        id: 'blocked-model',
-        provider: :contract,
-        instance: :primary,
-        capabilities: %i[completion],
-        context_length: 4096
+    # 0.8.0 (07 C5): the legacy ModelOffering production path is deleted — the
+    # per-gem writer publishes; the base read path serves the activated
+    # inventory offerings for this instance from the registry snapshot.
+    def activate_contract_instance
+      key = Legion::Extensions::Llm::Inventory::Identity::InstanceKey.new(
+        provider_family: 'provider', instance_id: 'primary'
       )
-      registry_publisher = instance_double(Legion::Extensions::Llm::RegistryPublisher)
-      allow(registry_publisher).to receive(:publish_models_async)
-      allow(provider_class).to receive(:registry_publisher).and_return(registry_publisher)
-      allow(provider).to receive_messages(list_models: [model, blocked_model], settings: { model_blacklist: ['blocked'] })
-
-      offerings = provider.discover_offerings(live: true)
-
-      expect(offerings.map(&:model)).to eq(['test-model'])
-      expect(registry_publisher).to have_received(:publish_models_async).with([model], anything)
-      expect(registry_publisher).to have_received(:publish_models_async).with([blocked_model], anything)
+      Legion::Extensions::Llm::Inventory::Registry.reset!
+      claim_and_activate(key: key, callable: Object.new, coordinator: probe_coordinator(key), model: 'test-model')
     end
 
-    it 'passes live discovery filters through to list_models' do
-      provider.discover_offerings(live: true, capability: :tools, instance: :primary)
+    it 'serves the activated inventory offerings for the instance from the registry snapshot (07 C5)' do
+      activate_contract_instance
+      offerings = provider.discover_offerings
 
-      expect(provider.list_model_calls).to include(
-        live: true,
-        filters: { capability: :tools, instance: :primary }
-      )
+      expect(offerings.size).to eq(1)
+      expect(offerings.first.model).to eq('test-model')
+      expect(offerings.first.instance_key.instance_id).to eq('primary')
+      expect(offerings.first.instance_key.provider_family).to eq(:provider)
     end
 
-    it 'filters generated offerings by capability and instance' do
-      provider.discover_offerings(live: true)
+    it 'filters snapshot offerings by model and instance keys' do
+      activate_contract_instance
 
-      expect(provider.discover_offerings(capability: :tools, instance: :primary)).not_to be_empty
-      expect(provider.discover_offerings(capability: :embedding)).to be_empty
-      expect(provider.discover_offerings(instance: :other)).to be_empty
+      expect(provider.discover_offerings(model: 'test-model')).not_to be_empty
+      expect(provider.discover_offerings(id: 'test-model')).not_to be_empty
+      expect(provider.discover_offerings(model: 'other-model')).to be_empty
+      expect(provider.discover_offerings(instance: 'other')).to be_empty
     end
 
-    it 'does not perform live discovery for uncached non-live offerings reads' do
+    it 'never calls list_models — the production path moved to the per-gem writer' do
       allow(provider).to receive(:list_models).and_raise('unexpected live discovery')
 
-      expect(provider.discover_offerings).to eq([])
+      expect { provider.discover_offerings(live: true) }.not_to raise_error
       expect(provider).not_to have_received(:list_models)
     end
 
-    it 'serves non-live offerings reads from the live discovery cache' do
-      provider.discover_offerings(live: true)
-      allow(provider).to receive(:list_models).and_raise('unexpected live discovery')
+    describe 'H5 — honest read-path contract (accepted-for-compat params are documented, not silently discarded)' do
+      it 'accepts the full discover_offerings signature against the snapshot' do
+        expect { provider.discover_offerings(live: true, raise_on_unreachable: true) }.not_to raise_error
+        expect(provider.discover_offerings(raise_on_unreachable: true, model: 'test-model').size).to eq(1)
+      end
+    end
+
+    describe 'H3 — the funnel enforces the tool contract (one contract, one oracle)' do
+      let(:tool) { Legion::Extensions::Llm::Canonical::ToolDefinition.build(name: 'get_weather') }
+
+      before do
+        allow(provider).to receive(:sync_response).and_return('ok') # -- stream_response's model: kwarg is not exercised here
+        allow(provider).to receive(:stream_response) { |_connection, _payload, _headers, **_opts, &stream_block| stream_block&.call('c') }
+      end
+
+      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-next Lint/EmptyBlock -- the streamed chunk is consumed by the stub
+          provider.stream_chat([], model: 'test-model', tools: { get_weather: tool }) { |_c| }
+        end.not_to raise_error
+      end
+
+      it 'rejects Hash tool values with a typed ArgumentError' do
+        expect { provider.chat([], model: 'test-model', tools: { get_weather: { name: 'get_weather' } }) }
+          .to raise_error(ArgumentError, /Canonical::ToolDefinition/)
+      end
 
-      expect(provider.discover_offerings(capability: :tools, instance: :primary)).not_to be_empty
+      it 'rejects a non-Hash tools container with a typed ArgumentError' do
+        expect { provider.chat([], model: 'test-model', tools: [tool]) }
+          .to raise_error(ArgumentError, /Hash<name, Canonical::ToolDefinition>/)
+      end
+
+      it 'rejects legacy tool objects with a typed ArgumentError' do
+        expect { provider.chat([], model: 'test-model', tools: { get_weather: Legion::Extensions::Llm::Tool.new }) }
+          .to raise_error(ArgumentError, /Canonical::ToolDefinition/)
+      end
     end
 
     it 'returns normalized health metadata' do
@@ -237,16 +233,17 @@ RSpec.describe Legion::Extensions::Llm::Provider do
     end
 
     it 'provides a deterministic token estimate fallback' do
-      expect(provider.count_tokens(messages: [{ content: 'hello world' }], model: model)).to be >= 1
+      messages = [Legion::Extensions::Llm::Canonical::Message.build(role: :user, content: 'hello world')]
+      expect(provider.count_tokens(messages: messages, model: 'test-model')).to be >= 1
     end
 
-    it 'summarizes hash-backed tools for debug logging' do
+    it 'summarizes canonical tools for debug logging' do
       tools = {
-        current: { name: 'current' },
-        legacy: { 'name' => 'legacy' }
+        current: Legion::Extensions::Llm::Canonical::ToolDefinition.build(name: 'current'),
+        other: Legion::Extensions::Llm::Canonical::ToolDefinition.build(name: 'other')
       }
 
-      expect(provider.send(:debug_tool_names, tools)).to eq(%w[current legacy])
+      expect(provider.send(:debug_tool_names, tools)).to eq(%w[current other])
     end
 
     it 'deep merges embedding params into the provider payload' do
@@ -375,6 +372,28 @@ RSpec.describe Legion::Extensions::Llm::Provider do
         expect(provider.model_allowed?('gpt-5')).to be true
       end
     end
+
+    context 'when the model is an object exposing #id' do
+      let(:model_info) do
+        Struct.new(:id).new('claude-sonnet-4-6')
+      end
+
+      before { provider.settings = { model_whitelist: %w[sonnet] } }
+
+      it 'matches policy against the model id, not the inspect string' do
+        expect(provider.model_allowed?(model_info)).to be true
+      end
+
+      it 'blocks object models the whitelist does not cover' do
+        other = Struct.new(:id).new('llama-3')
+        expect(provider.model_allowed?(other)).to be false
+      end
+
+      it 'never matches inspect-string artifacts (e.g. a data/name pattern)' do
+        provider.settings = { model_whitelist: %w[data] }
+        expect(provider.model_allowed?(model_info)).to be false
+      end
+    end
   end
 
   describe '#enforce_model_allowed! (dispatch compliance guard)' do
@@ -407,7 +426,7 @@ RSpec.describe Legion::Extensions::Llm::Provider do
       end
 
       it 'fails closed in #complete before any provider call' do
-        expect { provider.complete([], tools: [], temperature: nil, model: 'gpt-5') }
+        expect { provider.complete([], tools: [], model: 'gpt-5') }
           .to raise_error(Legion::Extensions::Llm::ModelNotAllowedError)
       end
 
@@ -421,7 +440,7 @@ RSpec.describe Legion::Extensions::Llm::Provider do
       before { provider.settings = { model_blacklist: %w[sonnet] } }
 
       it 'fails closed in #complete for a blacklisted model' do
-        expect { provider.complete([], tools: [], temperature: nil, model: 'claude-sonnet-4-6') }
+        expect { provider.complete([], tools: [], model: 'claude-sonnet-4-6') }
           .to raise_error(Legion::Extensions::Llm::ModelNotAllowedError)
       end
     end

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

@@ -16,9 +16,11 @@ RSpec.describe Legion::Extensions::Llm::Routing::Records do
   end
   let(:callable_handle) { inventory::CallableHandle.new(handle_id: 'call:v1:x', callable: callable_class.new) }
   let(:instance_key) { identity::InstanceKey.new(provider_family: 'vllm', instance_id: 'h200') }
-  let(:offering_id) { identity.offering_id(instance_key: instance_key, provider_native_key: 'gemma4') }
   let(:lane_id) do
-    identity.lane_id(instance_key: instance_key, operation: :chat, model: 'gemma4', offering_id: offering_id)
+    identity.compose_lane_id(
+      tier: :local, provider_family: 'vllm', instance_id: 'h200',
+      type: Legion::Extensions::Llm::Taxonomies.lane_type_for(operation: :chat), model: 'gemma4'
+    )
   end
 
   describe routing::AttemptTargetKey do
@@ -76,7 +78,7 @@ RSpec.describe Legion::Extensions::Llm::Routing::Records do
   describe routing::Selection do
     def build_selection(**overrides)
       Legion::Extensions::Llm::Routing::Selection.new(
-        inventory_generation: 7, lane_id: lane_id, instance_key: instance_key, offering_id: offering_id,
+        inventory_generation: 7, lane_id: lane_id, instance_key: instance_key,
         provider_family: :vllm, instance_id: 'h200', model: 'gemma4', operation: :chat,
         callable_handle: callable_handle, publisher_token_id: 'ptok:v1:abc', capability_evidence: {},
         context_evidence: Legion::Extensions::Llm::Inventory::ValueEvidence.new(status: :unknown, source: :absent),
@@ -88,6 +90,8 @@ RSpec.describe Legion::Extensions::Llm::Routing::Records do
 
     it 'builds a valid selection and derives the attempt target key' do
       selection = build_selection
+      expect(selection.lane_id).to eq('local:vllm:h200:inference:gemma4')
+      expect(selection.members).not_to include(:offering_id)
       key = selection.attempt_target_key
       expect(key).to eq(routing::AttemptTargetKey.new(provider_family: :vllm, instance_id: 'h200', model: 'gemma4'))
     end
@@ -105,8 +109,37 @@ RSpec.describe Legion::Extensions::Llm::Routing::Records do
         .to raise_error(errors::ValidationError)
     end
 
-    it 'rejects a lane_id that does not reproduce' do
-      expect { build_selection(lane_id: "lane:v1:#{'0' * 64}") }.to raise_error(errors::ValidationError)
+    it 'rejects a lane_id that is not a 5-tuple' do
+      expect { build_selection(lane_id: 'not-a-five-tuple') }
+        .to raise_error(errors::ValidationError)
+    end
+
+    it 'rejects a lane_id whose family part disagrees with the selection' do
+      expect { build_selection(lane_id: 'local:openai:h200:inference:gemma4') }
+        .to raise_error(errors::ValidationError, /provider_family/)
+    end
+
+    it 'rejects a lane_id whose instance part disagrees with the selection' do
+      expect { build_selection(lane_id: 'local:vllm:helios1:inference:gemma4') }
+        .to raise_error(errors::ValidationError, /instance_id/)
+    end
+
+    it 'rejects a lane_id whose type part disagrees with the operation' do
+      expect { build_selection(lane_id: 'local:vllm:h200:embedding:gemma4') }
+        .to raise_error(errors::ValidationError, /type/)
+    end
+
+    it 'rejects a lane_id whose model part disagrees with the selection' do
+      expect { build_selection(lane_id: 'local:vllm:h200:inference:other-model') }
+        .to raise_error(errors::ValidationError, /model/)
+    end
+
+    it 'keeps colons inside the lane id model part' do
+      colon_model = 'llama3.2:8b-instruct'
+      id = identity.compose_lane_id(
+        tier: :local, provider_family: 'vllm', instance_id: 'h200', type: :inference, model: colon_model
+      )
+      expect(build_selection(lane_id: id, model: colon_model).lane_id).to eq(id)
     end
 
     it 'rejects a publisher_token_id without the ptok:v1: prefix' do