lex-llm 0.7.6 → 0.8.4

data/spec/legion/extensions/llm/inventory/registry_activation_spec.rb

@@ -21,7 +21,6 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
       snapshot = described_class.snapshot
       expect(snapshot.generation).to eq(0)
       expect(snapshot.each_lane.to_a).to be_empty
-      expect(snapshot.each_offering.to_a).to be_empty
       expect(snapshot.instance(instance_key: key)).to be_nil
     end
   end
@@ -63,33 +62,67 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
         .to raise_error(errors::InvalidTransitionError)
     end
 
-    it 'atomically publishes callable, offerings, lanes, and available on activation' do
+    it 'atomically publishes callable, lanes, and available on activation' do
       claim_and_activate(key: key, callable: callable, coordinator: coordinator)
       snapshot = described_class.snapshot
       record = snapshot.instance(instance_key: key)
       expect(record).not_to be_nil
       expect(record.availability.state).to eq(:available)
       expect(snapshot.lanes_for(instance_key: key).size).to eq(1)
-      expect(snapshot.offerings_for(instance_key: key).size).to eq(1)
       expect(snapshot.publication_status(instance_key: key).state).to eq(:complete)
     end
 
-    it 'copies the draft weight pair unchanged onto offering and lane records' do
-      weights = { tier: 150, provider: 100, instance: 115, model_or_offering: 100 }
+    it 'stores the lane keyed by the 5 tuple and exposes it through the record' do
+      claim_and_activate(key: key, callable: callable, coordinator: coordinator)
+      snapshot = described_class.snapshot
+      lane = snapshot.lanes_for(instance_key: key).first
+      expect(lane.lane_id).to eq('local:vllm:h200:inference:gemma4')
+      expect(snapshot.lane(lane_id: lane.lane_id)).to be(lane)
+      expect(snapshot.instance(instance_key: key).lanes_by_id.keys).to eq([lane.lane_id])
+    end
+
+    it 'derives one lane per supported operation of each draft' do
       claim_and_activate(
-        key: key, callable: callable, coordinator: coordinator,
-        weight_inputs: weights, base_weight: 172_500_000
+        key: key, callable: callable, coordinator: coordinator, supported: %i[chat embed]
       )
       snapshot = described_class.snapshot
-      offering = snapshot.offerings_for(instance_key: key).first
-      lane = snapshot.lanes_for(instance_key: key).first
+      expect(snapshot.lanes_for(instance_key: key).map(&:lane_id).sort).to eq(
+        %w[local:vllm:h200:embedding:gemma4 local:vllm:h200:inference:gemma4]
+      )
+    end
+
+    it 'raises on a duplicate (operation, model) published under a conflicting tier (D1)' do
+      key2 = instance_key(instance: 'tier-collision')
+      coordinator2 = probe_coordinator(key2)
+      token = described_class.claim_instance(instance_key: key2, callable: callable, probe_request_handle: coordinator2)
+      probe = described_class.readiness_probe_started(instance_key: key2, publisher_token: token)
+      expect do
+        described_class.activate_instance_snapshot(
+          publisher_token: token, instance_key: key2,
+          offerings: [
+            *drafts(model: 'm1', native: 'm1-a', supported: %i[chat], tier: :local),
+            *drafts(model: 'm1', native: 'm1-b', supported: %i[chat], tier: :frontier)
+          ],
+          sequence: 0, probe_token: probe
+        )
+      end.to raise_error(inventory::Errors::ValidationError, /conflicting tier/)
+    end
 
-      expect(offering.weight_inputs).to eq(weights)
-      expect(offering.base_weight).to eq(172_500_000)
-      expect(lane.weight_inputs).to eq(weights)
-      expect(lane.base_weight).to eq(172_500_000)
-      expect(offering.weight_inputs).to be_frozen
-      expect(lane.weight_inputs).to be_frozen
+    it 'raises on a duplicate 5 tuple from two native keys of the same model' do
+      key3 = instance_key(instance: 'dup-tuple')
+      coordinator3 = probe_coordinator(key3)
+      token = described_class.claim_instance(instance_key: key3, callable: callable, probe_request_handle: coordinator3)
+      probe = described_class.readiness_probe_started(instance_key: key3, publisher_token: token)
+      expect do
+        described_class.activate_instance_snapshot(
+          publisher_token: token, instance_key: key3,
+          offerings: [
+            *drafts(model: 'm1', native: 'm1-a', supported: %i[chat], tier: :local),
+            *drafts(model: 'm1', native: 'm1-b', supported: %i[chat], tier: :local)
+          ],
+          sequence: 0, probe_token: probe
+        )
+      end.to raise_error(inventory::Errors::ValidationError, /duplicate lane_id/)
     end
 
     it 'accepts an explicit complete empty activation as complete, not initializing' do
@@ -101,7 +134,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
       expect(result.applied).to be(true)
       snapshot = described_class.snapshot
       expect(snapshot.publication_status(instance_key: key).state).to eq(:complete)
-      expect(snapshot.instance(instance_key: key).offerings_by_id).to eq({})
+      expect(snapshot.instance(instance_key: key).lanes_by_id).to eq({})
     end
 
     it 'consumes the probe token so it cannot be reused' do

data/spec/legion/extensions/llm/inventory/registry_replacement_spec.rb

@@ -23,8 +23,9 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
     )
     expect(result.applied).to be(true)
     expect(result.reason).to eq(:snapshot_replaced)
-    offerings = described_class.snapshot.offerings_for(instance_key: key)
-    expect(offerings.map(&:provider_native_key)).to eq(['gemma5'])
+    lanes = described_class.snapshot.lanes_for(instance_key: key)
+    expect(lanes.map(&:model)).to eq(['gemma5'])
+    expect(lanes.map(&:lane_id)).to eq(%w[local:vllm:h200:inference:gemma5])
   end
 
   it 'preserves the exact availability fact across replacement' do
@@ -45,7 +46,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
   it 'treats an empty array as an authoritative complete empty snapshot' do
     token
     described_class.replace_instance_snapshot(publisher_token: token, instance_key: key, offerings: [], sequence: 1)
-    expect(described_class.snapshot.offerings_for(instance_key: key)).to be_empty
+    expect(described_class.snapshot.lanes_for(instance_key: key)).to be_empty
     expect(described_class.snapshot.instance(instance_key: key).availability.state).to eq(:available)
   end
 
@@ -56,7 +57,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Registry do
     expect { described_class.replace_instance_snapshot(publisher_token: token, instance_key: key, offerings: duplicate, sequence: 1) }
       .to raise_error(errors::ValidationError)
     expect(described_class.snapshot.generation).to eq(generation)
-    expect(described_class.snapshot.offerings_for(instance_key: key).size).to eq(1)
+    expect(described_class.snapshot.lanes_for(instance_key: key).size).to eq(1)
   end
 
   it 'returns a stale publisher result for a superseded token' do

data/spec/legion/extensions/llm/inventory/snapshot_spec.rb

@@ -26,8 +26,7 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Snapshot do
       record = snapshot.instance(instance_key: key_a)
       expect(record).to be_frozen
       expect(snapshot.instance(instance_key: instance_key(instance: 'absent'))).to be_nil
-      expect(snapshot.lane(lane_id: 'lane:v1:missing')).to be_nil
-      expect(snapshot.offering(offering_id: 'off:v1:missing')).to be_nil
+      expect(snapshot.lane(lane_id: 'local:absent:absent:inference:missing')).to be_nil
     end
 
     it 'only lists activated instances but keeps initializing claims in publication status' do
@@ -41,17 +40,24 @@ RSpec.describe Legion::Extensions::Llm::Inventory::Snapshot do
   end
 
   describe 'ordering and iteration' do
-    it 'returns frozen lanes_for/offerings_for arrays ordered by id' do
+    it 'returns a frozen lanes_for array ordered by 5-tuple id' do
       snapshot = activate_both
       lanes = snapshot.lanes_for(instance_key: key_a)
       expect(lanes).to be_frozen
       expect(lanes.map(&:lane_id)).to eq(lanes.map(&:lane_id).sort)
+      expect(lanes.map(&:lane_id)).to all(match(/\A[a-z_]+:[a-z_0-9]+:[^:]+:[a-z_]+:.+\z/))
     end
 
-    it 'each_lane/each_offering yield in id order and return an Enumerator without a block' do
+    it 'exposes lanes only — no offering surface' do
+      snapshot = activate_both
+      expect(snapshot).not_to respond_to(:offering)
+      expect(snapshot).not_to respond_to(:offerings_for)
+      expect(snapshot).not_to respond_to(:each_offering)
+    end
+
+    it 'each_lane yields in id order and returns an Enumerator without a block' do
       snapshot = activate_both
       expect(snapshot.each_lane).to be_a(Enumerator)
-      expect(snapshot.each_offering).to be_a(Enumerator)
       expect(snapshot.each_lane.map(&:lane_id)).to eq(snapshot.each_lane.map(&:lane_id).sort)
     end
   end

data/spec/legion/extensions/llm/inventory/weight_reconciler_spec.rb

@@ -244,13 +244,17 @@ RSpec.describe 'Inventory::WeightReconciler' do
   end
 
   it 'uses the exact provider, instance, model, instance-model, and offering dormant keys' do
-    offering_id = inventory::Identity.offering_id(instance_key: key, provider_native_key: 'gemma4')
+    # The offering-scope key is the lane's 5 tuple — operator-readable.
+    offering_lane_id = inventory::Identity.compose_lane_id(
+      tier: :local, provider_family: 'vllm', instance_id: 'helios', type: :inference, model: 'gemma4'
+    )
+    expect(offering_lane_id).to eq('local:vllm:helios:inference:gemma4')
     settings = settings_for(
       provider: {
         weight: false,
         models: { gemma4: { weight: 101 } },
         instances: { helios: { weight: 0, models: { gemma4: { weight: 102 } } } },
-        offerings: { offering_id => { weight: 103 } }
+        offerings: { offering_lane_id => { weight: 103 } }
       },
       tier: 777
     )
@@ -266,7 +270,7 @@ RSpec.describe 'Inventory::WeightReconciler' do
       [:vllm, :instance, 'helios'],
       [:vllm, :model, 'gemma4'],
       [:vllm, :instance, 'helios', :model, 'gemma4'],
-      [:vllm, :offering, offering_id]
+      [:vllm, :offering, offering_lane_id]
     )
     expect(logged.flatten).not_to include(:tier)
 

data/spec/legion/extensions/llm/inventory/weight_schema_spec.rb

@@ -12,25 +12,38 @@ RSpec.describe 'Inventory::WeightSchema' do
     inventory::Identity::InstanceKey.new(provider_family: :vllm, instance_id: 'helios')
   end
 
+  def operation_evidence(supported: %i[chat], **)
+    Legion::Extensions::Llm::Taxonomies::OPERATIONS.to_h do |op|
+      status, source = supported.include?(op) ? %i[supported provider_implementation] : %i[unknown absent]
+      [op, Legion::Extensions::Llm::Inventory::OperationEvidence.new(operation: op, status: status, source: source)]
+    end
+  end
+
   def settings_for(provider: {})
     { extensions: { llm: { vllm: provider } }, llm: { routing: { tier_weights: { direct: 100 } } } }
   end
 
-  def inputs(settings, native: 'deployment-x', model: 'model-y')
+  # The offering-scope settings key is the lane's 5 tuple (operator-readable).
+  def lane_id(tier: :direct, model: 'model-y', type: :inference)
+    Legion::Extensions::Llm::Inventory::Identity.compose_lane_id(
+      tier: tier, provider_family: 'vllm', instance_id: 'helios', type: type, model: model
+    )
+  end
+
+  def inputs(settings, operation: :chat, model: 'model-y')
     schema.weight_inputs(
-      settings: settings, instance_key: instance_key,
-      provider_native_key: native, model: model, tier: :direct
+      settings: settings, instance_key: instance_key, model: model, tier: :direct,
+      operation_evidence: operation_evidence(supported: [operation])
     )
   end
 
   it 'multiplies independent scopes without double-counting and lets offering override model' do
-    offering_id = inventory::Identity.offering_id(instance_key: instance_key, provider_native_key: 'deployment-x')
     settings = settings_for(
       provider: {
         weight: 100,
         models: { 'model-y' => { weight: 200 } },
         instances: { helios: { weight: 115 } },
-        offerings: { offering_id => { weight: 300 } }
+        offerings: { lane_id => { weight: 300 } }
       }
     )
 
@@ -60,16 +73,53 @@ RSpec.describe 'Inventory::WeightSchema' do
     expect(schema.base_weight(identity)).to eq(100_000_000)
   end
 
-  it 'derives offering identity from the provider-native key rather than the model' do
-    deployment_id = inventory::Identity.offering_id(
-      instance_key: instance_key, provider_native_key: 'deployment-x'
+  it 'treats the offering scope as the lane 5 tuple: a different model key does not apply' do
+    other_model_key = lane_id(model: 'other-model')
+    settings = settings_for(
+      provider: { offerings: { other_model_key => { weight: 999 }, lane_id => { weight: 321 } } }
     )
-    model_id = inventory::Identity.offering_id(instance_key: instance_key, provider_native_key: 'model-y')
-    settings = settings_for(provider: { offerings: { deployment_id => { weight: 321 }, model_id => { weight: 999 } } })
 
     expect(inputs(settings)[:model_or_offering]).to eq(321)
   end
 
+  it 'derives the offering scope type from the operation: an embed key does not apply to a chat lane' do
+    embed_key = lane_id(type: :embedding)
+    settings = settings_for(provider: { offerings: { embed_key => { weight: 999 } } })
+
+    expect(inputs(settings, operation: :embed)[:model_or_offering]).to eq(999)
+    expect(inputs(settings)[:model_or_offering]).to eq(100) # chat draft: no inference key configured
+  end
+
+  it 'falls through to the model scope when no offering-scope key is configured' do
+    settings = settings_for(provider: { models: { 'model-y' => { weight: 200 } } })
+    expect(inputs(settings)[:model_or_offering]).to eq(200)
+  end
+
+  it 'raises when a multi-type draft has differing configured weights across its lanes' do
+    inference_key = lane_id(type: :inference)
+    embedding_key = lane_id(type: :embedding)
+    settings = settings_for(
+      provider: { offerings: { inference_key => { weight: 100 }, embedding_key => { weight: 200 } } }
+    )
+    expect do
+      schema.weight_inputs(
+        settings: settings, instance_key: instance_key, model: 'model-y', tier: :direct,
+        operation_evidence: operation_evidence(supported: %i[chat embed])
+      )
+    end.to raise_error(ArgumentError, /ambiguous/)
+
+    # Equal weights across the draft's lanes resolve to that weight.
+    settings = settings_for(
+      provider: { offerings: { inference_key => { weight: 100 }, embedding_key => { weight: 100 } } }
+    )
+    expect(
+      schema.weight_inputs(
+        settings: settings, instance_key: instance_key, model: 'model-y', tier: :direct,
+        operation_evidence: operation_evidence(supported: %i[chat embed])
+      )[:model_or_offering]
+    ).to eq(100)
+  end
+
   it 'rejects every present malformed configuration scope instead of defaulting it' do
     cases = {
       'extensions.llm' => { extensions: { llm: false } },

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

@@ -3,6 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Legion::Extensions::Llm::Provider::OpenAICompatible do
+  let(:canonical) { Legion::Extensions::Llm::Canonical }
   let(:provider_class) do
     capability_object = Object.new
     def capability_object.chat?(model) = !embeddings?(model)
@@ -18,89 +19,158 @@ RSpec.describe Legion::Extensions::Llm::Provider::OpenAICompatible do
     end
   end
   let(:provider) { provider_class.new(Legion::Extensions::Llm.config) }
-  let(:model) { Legion::Extensions::Llm::Model::Info.from_hash(id: 'model-a', provider: :openai_compatible) }
+  let(:model_id) { 'model-a' }
 
-  it 'renders chat payloads for OpenAI-compatible servers' do
+  it 'renders chat payloads for OpenAI-compatible servers (canonical in, O4 temperature from Params)' do
     payload = chat_payload
 
-    expect(payload.values_at(:model, :stream, :temperature)).to eq(['model-a', false, 0.2])
+    expect(payload.values_at(:model, :stream, :temperature)).to eq([model_id, false, 0.2])
     expect(payload[:messages]).to eq([{ role: 'user', content: 'hello' }])
   end
 
   it 'preserves assistant think tags in outbound OpenAI-compatible history' do
-    message = Legion::Extensions::Llm::Message.new(
+    message = canonical::Message.build(
       role: :assistant,
-      content: "internal\n</think>\n\nHello"
+      content: "internal\n</thinking>\n\nHello"
     )
 
     payload = provider.send(
       :render_payload,
       [message],
       tools: {},
-      temperature: 0.2,
-      model: model,
+      model: model_id,
       stream: false,
       schema: nil,
       thinking: nil,
-      tool_prefs: nil
+      tool_prefs: nil,
+      params: canonical::Params.build(temperature: 0.2)
     )
 
-    expect(payload[:messages]).to eq([{ role: 'assistant', content: "internal\n</think>\n\nHello" }])
+    expect(payload[:messages]).to eq([{ role: 'assistant', content: "internal\n</thinking>\n\nHello" }])
   end
 
-  it 'parses chat completion responses with usage and tool calls' do
-    message = provider.send(:parse_completion_response, fake_response(completion_body))
+  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,
+      content: [canonical::ContentBlock.text('look at this'),
+                canonical::ContentBlock.image(data: 'AAA=', media_type: 'image/png')]
+    )
+
+    payload = provider.send(
+      :render_payload,
+      [message],
+      tools: {},
+      model: model_id,
+      stream: false,
+      schema: nil,
+      thinking: nil,
+      tool_prefs: nil,
+      params: nil
+    )
+
+    # Text blocks render as plain strings; non-text blocks as OpenAI content parts.
+    expect(payload[:messages].first[:content]).to eq(
+      ['look at this', { type: 'image', data: 'AAA=', media_type: 'image/png', source_type: :base64 }]
+    )
+  end
+
+  it 'parses chat completion responses to a Canonical::Response with usage and tool calls (08 R2)' do
+    response = provider.send(:parse_completion_response, fake_response(completion_body))
+
+    expect(response).to be_a(canonical::Response)
+    expect([response.text, response.usage.input_tokens, response.usage.output_tokens]).to eq(['hi', 3, 5])
+    expect(response.tool_calls.first).to be_a(canonical::ToolCall)
+    expect(response.tool_calls.first.arguments).to eq('id' => 1)
+    expect(response.stop_reason).to be_nil
+  end
 
-    expect([message.content, message.input_tokens, message.output_tokens]).to eq(['hi', 3, 5])
-    expect(message.tool_calls[:lookup].arguments).to eq('id' => 1)
+  it 'maps finish_reason through the StopReasonMapping vocabulary' do
+    response = provider.send(
+      :parse_completion_response,
+      fake_response({
+                      'model' => 'model-a',
+                      'choices' => [{ 'message' => { 'content' => 'hi' }, 'finish_reason' => 'tool_calls' }]
+                    })
+    )
+
+    expect(response.stop_reason).to eq(:tool_use)
   end
 
   it 'strips malformed trailing think close tags from chat completion responses' do
-    message = provider.send(
+    response = provider.send(
       :parse_completion_response,
-      fake_response(completion_body(content: "hidden only\n</think>\n\nvisible"))
+      fake_response(completion_body(content: "hidden only\n</thinking>\n\nvisible"))
     )
 
-    expect(message.content).to eq('visible')
-    expect(message.thinking.text).to eq('hidden only')
+    expect(response.text).to eq('visible')
+    expect(response.thinking.content).to eq('hidden only')
   end
 
   it 'strips truncated think tags from chat completion responses' do
-    message = provider.send(
+    response = provider.send(
       :parse_completion_response,
-      fake_response(completion_body(content: "visible\n<think>hidden only"))
+      fake_response(completion_body(content: "visible\n<thinking>hidden only"))
     )
 
-    expect(message.content).to eq('visible')
-    expect(message.thinking.text).to eq('hidden only')
+    expect(response.text).to eq('visible')
+    expect(response.thinking.content).to eq('hidden only')
   end
 
   it 'does not leak streamed think-tag content split across chunks' do
     accumulator = Legion::Extensions::Llm::StreamAccumulator.new
-    filtered = think_tag_stream.filter_map do |content|
-      chunk = provider.send(:build_chunk, stream_delta(content: content))
-      accumulator.add(chunk)
-      accumulator.filtered_chunk(chunk)
+    emitted = []
+
+    think_tag_stream.each do |content|
+      emitted.concat(accumulator.add(provider.send(:build_chunk, stream_delta(content: content))))
     end
 
-    message = accumulator.to_message(nil)
+    message = accumulator.to_response(model: model_id)
 
-    expect(filtered.filter_map(&:content)).to eq(['visible'])
-    expect(filtered.filter_map { |chunk| chunk.thinking&.text }.join).to eq('internal')
-    expect(message.content).to eq('visible')
-    expect(message.thinking.text).to eq('internal')
+    expect(emitted.select(&:text_delta?).map(&:delta)).to eq(['visible'])
+    expect(emitted.select(&:thinking_delta?).map(&:delta).join).to eq('internal')
+    expect(message.text).to eq('visible')
+    expect(message.thinking.content).to eq('internal')
   end
 
-  it 'ignores incomplete OpenAI-compatible tool call deltas without a function name' do
-    chunk = nil
+  it 'builds canonical chunks from streamed data (O5 — canonical out)' do
+    chunk = provider.send(:build_chunk, stream_delta(content: 'hello'))
+    expect(chunk).to be_a(canonical::Chunk)
+    expect(chunk.type).to eq(:text_delta)
+    expect(chunk.delta).to eq('hello')
 
-    expect do
-      chunk = provider.send(:build_chunk, stream_delta(tool_calls: [tool_call_delta_without_name]))
-    end.not_to raise_error
+    usage_chunk = provider.send(:build_chunk, { 'choices' => [], 'usage' => { 'prompt_tokens' => 2 } })
+    expect(usage_chunk.type).to eq(:usage)
+    expect(usage_chunk.usage.input_tokens).to eq(2)
+  end
 
-    expect(chunk.tool_calls[:'0'].id).to be_nil
-    expect(chunk.tool_calls[:'0'].name).to be_nil
-    expect(chunk.tool_calls[:'0'].arguments).to eq('{}')
+  it 'emits tool_call_delta chunks carrying the wire fragment (U1/U2 shapes)' do
+    chunk = provider.send(:build_chunk, stream_delta(tool_calls: [tool_call_delta_without_name]))
+    expect(chunk).to be_a(canonical::Chunk)
+    expect(chunk.type).to eq(:tool_call_delta)
+    expect(chunk.tool_call).to eq(id: nil, name: nil, arguments: '{}', index: 0)
   end
 
   it 'accumulates streamed OpenAI-compatible tool call argument fragments' do
@@ -110,52 +180,51 @@ RSpec.describe Legion::Extensions::Llm::Provider::OpenAICompatible do
       accumulator.add(provider.send(:build_chunk, stream_delta(tool_calls: [delta])))
     end
 
-    message = accumulator.to_message(nil)
-    expect(message.tool_calls['call-1'].arguments).to eq('city' => 'Chicago')
+    message = accumulator.to_response(model: model_id)
+    expect(message.tool_calls.first.name).to eq('lookup')
+    expect(message.tool_calls.first.arguments).to eq('city' => 'Chicago')
   end
 
   it 'renders embedding payloads with model ids' do
-    payload = provider.send(:render_embedding_payload, 'hello', model: model, dimensions: 768)
+    payload = provider.send(:render_embedding_payload, 'hello', model: model_id, dimensions: 768)
 
-    expect(payload).to eq(model: 'model-a', input: 'hello', dimensions: 768)
+    expect(payload).to eq(model: model_id, input: 'hello', dimensions: 768)
   end
 
-  it 'parses embedding responses for single and batch inputs' do
+  it 'parses embedding responses to the documented artifact Hash (05 §3)' do
     single = provider.send(:parse_embedding_response, fake_response(embedding_body), model: 'embed', text: 'a')
     batch = provider.send(:parse_embedding_response, fake_response(embedding_body), model: 'embed', text: %w[a b])
 
-    expect([single.vectors, batch.vectors]).to eq([[0.1], [[0.1], [0.2]]])
+    expect(single[:embedding]).to eq([0.1])
+    expect(batch[:embedding]).to eq([[0.1], [0.2]])
+    expect(single[:usage]).to be_a(canonical::Usage)
   end
 
-  it 'maps OpenAI-compatible model listings to explicit capabilities and modalities' do
-    models = provider.send(:parse_list_models_response, fake_response(models_body), :compatible,
-                           provider_class.capabilities)
+  it 'parses moderation responses to the documented artifact Hash (05 §3)' do
+    body = { 'model' => 'mod-1', 'results' => [{ 'flagged' => true, 'categories' => { 'hate' => true } }] }
+    result = provider.send(:parse_moderation_response, fake_response(body), model: 'mod-1')
 
-    expect(models.map(&:capabilities)).to eq([%i[streaming function_calling tools], %i[embeddings embedding]])
-    expect(models.map { |model| model.modalities.to_h }).to eq([
-                                                                 { input: %w[text image], output: %w[text] },
-                                                                 { input: %w[text], output: %w[embeddings] }
-                                                               ])
+    expect(result).to eq(model: 'mod-1', result: { flagged: true, categories: { 'hate' => true } })
   end
 
   def chat_payload
-    message = Legion::Extensions::Llm::Message.new(role: :user, content: 'hello')
+    message = canonical::Message.build(role: :user, content: 'hello')
     provider.send(
       :render_payload,
       [message],
       tools: {},
-      temperature: 0.2,
-      model: model,
+      model: model_id,
       stream: false,
       schema: nil,
       thinking: nil,
-      tool_prefs: nil
+      tool_prefs: nil,
+      params: canonical::Params.build(temperature: 0.2)
     )
   end
 
   def completion_body(content: 'hi')
     {
-      'model' => 'model-a',
+      'model' => model_id,
       'choices' => [{ 'message' => { 'content' => content, 'tool_calls' => [tool_call] } }],
       'usage' => { 'prompt_tokens' => 3, 'completion_tokens' => 5 }
     }
@@ -177,26 +246,17 @@ RSpec.describe Legion::Extensions::Llm::Provider::OpenAICompatible do
   end
 
   def think_tag_stream
-    ['<think>', 'internal', '</think>visible']
+    ['<thinking>', 'internal', '</thinking>visible']
   end
 
   def stream_delta(content: nil, tool_calls: nil)
-    { 'model' => 'model-a', 'choices' => [{ 'delta' => { 'content' => content, 'tool_calls' => tool_calls }.compact }] }
+    { 'model' => model_id, 'choices' => [{ 'delta' => { 'content' => content, 'tool_calls' => tool_calls }.compact }] }
   end
 
   def embedding_body
     { 'data' => [{ 'embedding' => [0.1] }, { 'embedding' => [0.2] }], 'usage' => { 'prompt_tokens' => 2 } }
   end
 
-  def models_body
-    {
-      'data' => [
-        { 'id' => 'chat-model', 'created' => 1 },
-        { 'id' => 'embed-model', 'created' => 2 }
-      ]
-    }
-  end
-
   def fake_response(body)
     Struct.new(:body).new(body)
   end