lex-llm 0.7.3 → 0.8.0

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,135 @@ 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))
+  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')]
+    )
 
-    expect([message.content, message.input_tokens, message.output_tokens]).to eq(['hi', 3, 5])
-    expect(message.tool_calls[:lookup].arguments).to eq('id' => 1)
+    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
+
+  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 +157,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 +223,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

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]]