lex-llm 0.5.0 → 0.5.3

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

@@ -9,7 +9,7 @@ RSpec.describe Legion::Extensions::Llm::Canonical::ToolDefinition do
 
       expect(tool.name).to eq('search')
       expect(tool.description).to eq('Search the web')
-      expect(tool.parameters).to eq({})
+      expect(tool.parameters).to eq(type: 'object', properties: {})
       expect(tool.source).to eq({ type: :builtin })
     end
 
@@ -113,7 +113,7 @@ RSpec.describe Legion::Extensions::Llm::Canonical::ToolDefinition do
       entry = {
         name: 'custom',
         description: 'Custom tool',
-        parameters: {},
+        parameters: { type: 'object', properties: { name: { type: 'string' } } },
         extension: 'custom-ext'
       }
       tool = described_class.from_registry_entry(entry)
@@ -160,6 +160,53 @@ RSpec.describe Legion::Extensions::Llm::Canonical::ToolDefinition do
     end
   end
 
+  describe '.normalize_parameters' do
+    it 'injects type: object when a schema has properties but no type' do
+      schema = { properties: { task: { type: 'string' } }, required: ['task'] }
+      result = described_class.normalize_parameters(schema)
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(task: { type: 'string' })
+      expect(result[:required]).to eq(['task'])
+    end
+
+    it 'passes schemas with an explicit type through unchanged' do
+      schema = { type: 'object', properties: { a: { type: 'string' } } }
+      expect(described_class.normalize_parameters(schema)).to eq(schema)
+    end
+
+    it 'wraps a bare property map under type:object/properties' do
+      expect(described_class.normalize_parameters(location: { type: 'string' }))
+        .to eq(type: 'object', properties: { location: { type: 'string' } })
+    end
+
+    it 'returns an empty object schema for nil/empty' do
+      expect(described_class.normalize_parameters(nil)).to eq(type: 'object', properties: {})
+      expect(described_class.normalize_parameters({})).to eq(type: 'object', properties: {})
+    end
+
+    it 'symbolizes top-level string keys' do
+      result = described_class.normalize_parameters('properties' => { 'a' => { 'type' => 'string' } })
+      expect(result[:type]).to eq('object')
+      expect(result).to have_key(:properties)
+    end
+
+    it 'leaves composite schemas (oneOf etc.) without forcing type' do
+      schema = { oneOf: [{ type: 'string' }, { type: 'integer' }] }
+      expect(described_class.normalize_parameters(schema)).to eq(schema)
+    end
+
+    it 'normalizes parameters at construction via .build' do
+      td = described_class.build(name: 'multi_agent_v1',
+                                 parameters: { properties: { task: { type: 'string' } } })
+      expect(td.parameters[:type]).to eq('object')
+    end
+
+    it 'normalizes nil parameters to empty object schema via .build' do
+      td = described_class.build(name: 'bare_tool')
+      expect(td.parameters).to eq(type: 'object', properties: {})
+    end
+  end
+
   describe 'round-trip' do
     it 'preserves values through from_hash/to_h' do
       original = { name: 'search', description: 'Search', parameters: { type: 'object' } }

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Llm::Canonical::ToolSchema do
+  let(:full_schema) { { type: 'object', properties: { city: { type: 'string' } }, required: ['city'] } }
+  let(:canonical_tool) do
+    Legion::Extensions::Llm::Canonical::ToolDefinition.build(
+      name: 'get_weather', description: 'Weather lookup', parameters: full_schema
+    )
+  end
+
+  describe '.extract' do
+    it 'extracts from a Canonical::ToolDefinition' do
+      result = described_class.extract(canonical_tool)
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'extracts from a Hash with :parameters' do
+      result = described_class.extract({ parameters: full_schema })
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'extracts from a Hash with :input_schema' do
+      result = described_class.extract({ input_schema: full_schema })
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'extracts from a Hash with :params_schema' do
+      result = described_class.extract({ params_schema: full_schema })
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'extracts from an object responding to params_schema' do
+      tool = Struct.new(:params_schema).new(full_schema)
+      result = described_class.extract(tool)
+      expect(result[:type]).to eq('object')
+      expect(result[:properties]).to eq(city: { type: 'string' })
+    end
+
+    it 'returns empty object schema for nil' do
+      expect(described_class.extract(nil)).to eq(type: 'object', properties: {})
+    end
+
+    it 'returns empty object schema for empty hash' do
+      expect(described_class.extract({})).to eq(type: 'object', properties: {})
+    end
+  end
+
+  describe '.tool_name' do
+    it 'gets name from Canonical::ToolDefinition' do
+      expect(described_class.tool_name(canonical_tool)).to eq('get_weather')
+    end
+
+    it 'gets name from Hash' do
+      expect(described_class.tool_name({ name: 'foo' })).to eq('foo')
+    end
+  end
+
+  describe '.tool_description' do
+    it 'gets description from Canonical::ToolDefinition' do
+      expect(described_class.tool_description(canonical_tool)).to eq('Weather lookup')
+    end
+
+    it 'gets description from Hash' do
+      expect(described_class.tool_description({ description: 'bar' })).to eq('bar')
+    end
+  end
+
+  describe 'ToolDefinition compatibility readers' do
+    it 'params_schema returns normalized parameters' do
+      expect(canonical_tool.params_schema).to eq(full_schema)
+    end
+
+    it 'input_schema aliases params_schema' do
+      expect(canonical_tool.input_schema).to eq(canonical_tool.params_schema)
+    end
+  end
+end

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

@@ -114,6 +114,46 @@ RSpec.describe Legion::Extensions::Llm::Canonical::Usage do
     end
   end
 
+  describe 'OpenAI nested details extraction' do
+    it 'extracts cached_tokens from prompt_tokens_details (Chat API)' do
+      usage = described_class.from_hash(
+        prompt_tokens: 1000,
+        completion_tokens: 200,
+        prompt_tokens_details: { cached_tokens: 800 },
+        completion_tokens_details: { reasoning_tokens: 50 }
+      )
+
+      expect(usage.input_tokens).to eq(1000)
+      expect(usage.output_tokens).to eq(200)
+      expect(usage.cache_read_tokens).to eq(800)
+      expect(usage.thinking_tokens).to eq(50)
+    end
+
+    it 'extracts cached_tokens from input_tokens_details (Responses API)' do
+      usage = described_class.from_hash(
+        input_tokens: 500,
+        output_tokens: 100,
+        input_tokens_details: { cached_tokens: 400 },
+        output_tokens_details: { reasoning_tokens: 30 }
+      )
+
+      expect(usage.input_tokens).to eq(500)
+      expect(usage.output_tokens).to eq(100)
+      expect(usage.cache_read_tokens).to eq(400)
+      expect(usage.thinking_tokens).to eq(30)
+    end
+
+    it 'prefers top-level cache_read_tokens over nested details' do
+      usage = described_class.from_hash(
+        input_tokens: 500,
+        cache_read_tokens: 300,
+        prompt_tokens_details: { cached_tokens: 400 }
+      )
+
+      expect(usage.cache_read_tokens).to eq(300)
+    end
+  end
+
   describe 'round-trip' do
     it 'preserves values through from_hash/to_h' do
       original = { input_tokens: 100, output_tokens: 50, cache_read_tokens: 10 }

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Llm::CapabilityPolicy do
+  let(:empty_sources) do
+    { real: {}, provider_catalog: {}, probe: {}, provider_envelope: {}, provider_config: {}, instance_config: {},
+      model_config: {} }
+  end
+
+  describe '.resolve' do
+    context 'with no data at all' do
+      it 'defaults all optional capabilities to false' do
+        policy = described_class.resolve(**empty_sources)
+
+        expect(policy[:capabilities]).to eq([])
+        expect(policy[:sources][:embeddings]).to eq(value: false, source: :default_false)
+        expect(policy[:sources][:thinking]).to eq(value: false, source: :default_false)
+        expect(policy[:sources][:streaming]).to eq(value: false, source: :default_false)
+        expect(policy[:sources][:tools]).to eq(value: false, source: :default_false)
+        expect(policy[:sources][:vision]).to eq(value: false, source: :default_false)
+      end
+    end
+
+    context 'with instance override' do
+      it 'resolves capabilities from instance config' do
+        policy = described_class.resolve(
+          real: {},
+          provider_catalog: {},
+          probe: {},
+          provider_envelope: {},
+          provider_config: {
+            capabilities: { embeddings: false },
+            tools_flag: false
+          },
+          instance_config: {
+            capabilities: { streaming: true, tools: true },
+            enable_thinking: true
+          },
+          model_config: {}
+        )
+
+        expect(policy[:capabilities]).to contain_exactly(:streaming, :tools, :thinking)
+        expect(policy[:sources][:thinking]).to eq(value: true, source: :instance_override)
+        expect(policy[:sources][:embeddings]).to eq(value: false, source: :provider_override)
+        expect(policy[:sources][:tools]).to eq(value: true, source: :instance_override)
+      end
+    end
+
+    context 'with provider-level override' do
+      it 'resolves capabilities from provider config' do
+        policy = described_class.resolve(
+          real: {},
+          provider_catalog: {},
+          probe: {},
+          provider_envelope: {},
+          provider_config: {
+            capabilities: { streaming: true },
+            embedding_flag: false,
+            thinking_flag: true
+          },
+          instance_config: {},
+          model_config: {}
+        )
+
+        expect(policy[:capabilities]).to contain_exactly(:streaming, :thinking)
+        expect(policy[:sources][:streaming]).to eq(value: true, source: :provider_override)
+        expect(policy[:sources][:embeddings]).to eq(value: false, source: :provider_override)
+        expect(policy[:sources][:thinking]).to eq(value: true, source: :provider_override)
+      end
+    end
+
+    context 'with full precedence chain' do
+      it 'resolves each capability from the highest-priority source' do
+        policy = described_class.resolve(
+          real: { tools: false, vision: true },
+          provider_catalog: { structured_output: true },
+          probe: { embeddings: true },
+          provider_envelope: { streaming: true, tools: true },
+          provider_config: { capabilities: { tools: true, vision: false } },
+          instance_config: { capabilities: { tools: false } },
+          model_config: { capabilities: { tools: true } }
+        )
+
+        expect(policy[:capabilities]).to include(:tools, :embeddings, :streaming, :structured_output)
+        expect(policy[:capabilities]).not_to include(:vision)
+        expect(policy[:sources][:tools]).to eq(value: true, source: :model_override)
+        expect(policy[:sources][:vision]).to eq(value: false, source: :provider_override)
+        expect(policy[:sources][:embeddings]).to eq(value: true, source: :probe)
+        expect(policy[:sources][:structured_output]).to eq(value: true, source: :provider_catalog)
+        expect(policy[:sources][:streaming]).to eq(value: true, source: :provider_envelope)
+      end
+    end
+
+    context 'with boolean aliases' do
+      it 'resolves enable_* and *_flag aliases' do
+        policy = described_class.resolve(
+          real: {},
+          provider_catalog: {},
+          probe: {},
+          provider_envelope: {},
+          provider_config: {},
+          instance_config: { enable_thinking: true, streaming_flag: true, tools_flag: false },
+          model_config: {}
+        )
+
+        expect(policy[:capabilities]).to contain_exactly(:streaming, :thinking)
+        expect(policy[:sources][:thinking]).to eq(value: true, source: :instance_override)
+        expect(policy[:sources][:streaming]).to eq(value: true, source: :instance_override)
+        expect(policy[:sources][:tools]).to eq(value: false, source: :instance_override)
+      end
+    end
+
+    context 'when capabilities hash wins over alias at same level' do
+      it 'prefers capabilities nested key over boolean alias' do
+        policy = described_class.resolve(
+          real: {},
+          provider_catalog: {},
+          probe: {},
+          provider_envelope: {},
+          provider_config: {},
+          instance_config: { capabilities: { tools: true }, tools_flag: false },
+          model_config: {}
+        )
+
+        expect(policy[:capabilities]).to include(:tools)
+        expect(policy[:sources][:tools]).to eq(value: true, source: :instance_override)
+      end
+    end
+
+    context 'with model override' do
+      it 'model override beats instance and provider' do
+        policy = described_class.resolve(
+          real: {},
+          provider_catalog: {},
+          probe: {},
+          provider_envelope: {},
+          provider_config: { capabilities: { thinking: false } },
+          instance_config: { capabilities: { thinking: false } },
+          model_config: { thinking_flag: true }
+        )
+
+        expect(policy[:capabilities]).to include(:thinking)
+        expect(policy[:sources][:thinking]).to eq(value: true, source: :model_override)
+      end
+    end
+
+    context 'with provider envelope' do
+      it 'uses provider envelope when no overrides exist' do
+        policy = described_class.resolve(
+          real: {},
+          provider_catalog: {},
+          probe: {},
+          provider_envelope: { streaming: true },
+          provider_config: {},
+          instance_config: {},
+          model_config: {}
+        )
+
+        expect(policy[:capabilities]).to contain_exactly(:streaming)
+        expect(policy[:sources][:streaming]).to eq(value: true, source: :provider_envelope)
+      end
+    end
+  end
+
+  describe '.normalized_overrides' do
+    it 'handles string keys in capabilities hash' do
+      result = described_class.normalized_overrides({ 'capabilities' => { 'streaming' => true } })
+      expect(result[:streaming]).to be(true)
+    end
+
+    it 'handles symbol keys in capabilities hash' do
+      result = described_class.normalized_overrides({ capabilities: { streaming: true } })
+      expect(result[:streaming]).to be(true)
+    end
+
+    it 'ignores non-boolean values' do
+      result = described_class.normalized_overrides({ capabilities: { streaming: 'yes' } })
+      expect(result).not_to have_key(:streaming)
+    end
+  end
+
+  describe '.normalize_hash' do
+    it 'returns empty hash for nil' do
+      expect(described_class.normalize_hash(nil)).to eq({})
+    end
+
+    it 'symbolizes keys' do
+      expect(described_class.normalize_hash({ 'foo' => 1 })).to eq({ foo: 1 })
+    end
+  end
+end

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

@@ -35,4 +35,44 @@ RSpec.describe Legion::Extensions::Llm::Configuration do
       expect(config.cache_control_prefix_tokens).to eq(4)
     end
   end
+
+  describe '.register_provider_options' do
+    after do
+      # Clean up test options to avoid polluting other specs
+      %i[test_api_key test_api_base].each do |key|
+        described_class.send(:option_keys).delete(key)
+        described_class.send(:defaults).delete(key)
+        described_class.send(:remove_method, key) if described_class.method_defined?(key)
+        described_class.send(:remove_method, :"#{key}=") if described_class.method_defined?(:"#{key}=")
+      end
+    end
+
+    it 'registers new options that become accessible on instances' do
+      described_class.register_provider_options(%i[test_api_key test_api_base])
+
+      config = described_class.new
+      expect(config).to respond_to(:test_api_key)
+      expect(config).to respond_to(:test_api_base)
+    end
+
+    it 'adds registered options to the options list' do
+      described_class.register_provider_options(%i[test_api_key test_api_base])
+
+      expect(described_class.options).to include(:test_api_key, :test_api_base)
+    end
+
+    it 'is idempotent — duplicate registrations do not add duplicates' do
+      described_class.register_provider_options(%i[test_api_key])
+      described_class.register_provider_options(%i[test_api_key])
+
+      count = described_class.options.count(:test_api_key)
+      expect(count).to eq(1)
+    end
+
+    it 'accepts string keys and normalizes them to symbols' do
+      described_class.register_provider_options(%w[test_api_key])
+
+      expect(described_class.options).to include(:test_api_key)
+    end
+  end
 end

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

@@ -265,5 +265,168 @@ RSpec.shared_examples 'a canonical client translator' do |translator_class|
       end
     end
   end
+
+  # G24 — execution-proxy response contract.
+  #
+  # When a server-executed LegionIO tool resolves before the canonical response
+  # is returned, the tool_call carries `:result` and a server-tool source
+  # (registry/special/extension/mcp). Client translators MUST surface that
+  # exchange as a completed, NON-actionable item — the client must not try to
+  # re-execute it. Per format:
+  #
+  #   * Claude /v1/messages — server_tool_use + server_tool_result content
+  #     blocks (NOT plain tool_use). stop_reason end_turn once all server
+  #     results are present.
+  #   * Codex /v1/responses — completed function_call items (or message items)
+  #     showing name+arguments+result, status 'completed' (NOT 'in_progress'
+  #     or 'requires_action'). The response status is 'completed', not
+  #     'requires_action'.
+  #   * Codex /v1/chat/completions — finish_reason 'stop' (not 'tool_calls')
+  #     when only server tools were called and they all have results; the
+  #     server tool exchange does not appear as actionable tool_calls.
+  #
+  # Translators declare their family via `g24_format` (one of :claude_messages,
+  # :openai_responses, :openai_chat) so the shared examples can pick the right
+  # shape assertions. Translators that don't implement g24_format are skipped.
+  describe 'G24 execution-proxy contract' do
+    let(:canonical_resp) do
+      canonical::Response.from_hash(conformance.fixture_symbolized('canonical_server_tool_use_response'))
+    end
+
+    let(:format) do
+      next nil unless translator.respond_to?(:g24_format)
+
+      translator.g24_format
+    end
+
+    context 'with a server-executed tool result in the canonical response' do
+      it 'surfaces the server tool name in the formatted response' do
+        next if format.nil?
+
+        formatted = translator.format_response(canonical_resp)
+        formatted_str = formatted.to_s
+        expect(formatted_str).to include('legion_list_all_tools')
+      end
+
+      it 'surfaces the server tool result text in the formatted response' do
+        next if format.nil?
+
+        formatted = translator.format_response(canonical_resp)
+        formatted_str = formatted.to_s
+        expect(formatted_str).to include('legion_list_all_tools, legion_apollo_search')
+      end
+
+      it 'never surfaces server-executed tools as actionable items', :aggregate_failures do
+        next if format.nil?
+
+        formatted = translator.format_response(canonical_resp)
+
+        case format
+        when :claude_messages
+          # Server-side tools must appear as server_tool_use, never tool_use.
+          # The G24 contract says the model must know the call happened AND
+          # the client must not re-execute, so server_tool_use+server_tool_result
+          # are the only shape — plain tool_use would put the client in a
+          # tool-loop trying to fulfill an already-resolved exchange.
+          types = (formatted[:content] || formatted['content']).map { |b| b[:type] || b['type'] }
+          expect(types).to include('server_tool_use')
+          expect(types).to include('server_tool_result')
+          expect(types).not_to include('tool_use')
+
+          stop_reason = formatted[:stop_reason] || formatted['stop_reason']
+          expect(stop_reason).to eq('end_turn')
+
+          server_use = (formatted[:content] || formatted['content']).find do |b|
+            (b[:type] || b['type']).to_s == 'server_tool_use'
+          end
+          expect(server_use[:name] || server_use['name']).to eq('legion_list_all_tools')
+
+          server_result = (formatted[:content] || formatted['content']).find do |b|
+            (b[:type] || b['type']).to_s == 'server_tool_result'
+          end
+          result_text = (server_result[:content] || server_result['content']).first
+          expect(result_text[:text] || result_text['text']).to include('legion_list_all_tools')
+        when :openai_responses
+          status = formatted[:status] || formatted['status']
+          expect(status).to eq('completed')
+
+          output = formatted[:output] || formatted['output']
+          actionable = output.select do |item|
+            type = (item[:type] || item['type']).to_s
+            status_str = (item[:status] || item['status']).to_s
+            type == 'function_call' && status_str != 'completed'
+          end
+          expect(actionable).to be_empty,
+                                "found actionable function_call items for server tools: #{actionable.inspect}"
+
+          # action_required is the legacy requires-action surface — server
+          # tools must never end up there.
+          action_required = formatted[:action_required] || formatted['action_required']
+          expect(action_required).to be_nil
+        when :openai_chat
+          choice = (formatted[:choices] || formatted['choices']).first
+          finish_reason = choice[:finish_reason] || choice['finish_reason']
+          expect(finish_reason).to eq('stop')
+
+          message = choice[:message] || choice['message']
+          actionable = (message[:tool_calls] || message['tool_calls'] || []).reject do |tc|
+            (tc[:status] || tc['status']).to_s == 'completed'
+          end
+          expect(actionable).to be_empty,
+                                "found actionable tool_calls for server tools: #{actionable.inspect}"
+        else
+          raise "unknown G24 format: #{format.inspect}"
+        end
+      end
+    end
+
+    it 'formats the streaming tool_call_delta with the registry source' do
+      next if format.nil?
+
+      # The streaming tool_call_delta carries the resolved server_tool result.
+      # We don't assert the per-chunk SSE encoding here (that's the route's
+      # event emitter contract); we assert format_chunk doesn't drop the call
+      # and the source flows through.
+      stream_fixture = conformance.fixture('canonical_streaming_server_tool_chunks')
+      tool_chunk = stream_fixture['chunks'].find do |c|
+        c['type'] == 'tool_call_delta' && c.dig('tool_call', 'result')
+      end
+      expect(tool_chunk).not_to be_nil
+
+      chunk = canonical::Chunk.from_hash(tool_chunk)
+      formatted = translator.format_chunk(chunk)
+
+      next if formatted.nil?
+
+      # Format-specific minimum: the tool name is reachable. Streaming
+      # shape per format is asserted in the matrix harness; here we only
+      # require that the server-tool name survives chunk formatting.
+      expect(formatted.to_s).to include('legion_list_all_tools')
+    end
+
+    it 'parses a continuation request with a prior server-executed exchange losslessly' do
+      next if format.nil?
+      next unless translator.respond_to?(:format_request)
+
+      # Each translator round-trips its own format. We render the canonical
+      # continuation with format_request (when available) then re-parse —
+      # the prior server tool exchange must survive intact.
+      continuation_body = conformance.fixture_symbolized('canonical_server_tool_continuation_request')
+      canonical_req = canonical::Request.from_hash(continuation_body)
+      formatted_body = translator.format_request(canonical_req)
+      next if formatted_body.nil?
+
+      parsed = translator.parse_request(formatted_body, {})
+      expect(parsed).to be_a(canonical::Request)
+
+      # The assistant tool_call and the tool result both survive the cycle.
+      roles = parsed.messages.map { |m| m.role.to_sym }
+      expect(roles).to include(:assistant)
+      expect(roles).to include(:tool)
+
+      tool_msg = parsed.messages.find { |m| m.role.to_sym == :tool }
+      expect(tool_msg.content.to_s).to include('legion_list_all_tools')
+    end
+  end
 end
 # rubocop:enable Lint/NonLocalExitFromIterator

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

@@ -0,0 +1,43 @@
+{
+  "description": "G24 round-trip — when a client sends back a history that contains a completed server-side exchange (Claude: server_tool_use+server_tool_result blocks; Codex: completed function_call+function_call_output items), the client translator must parse them into canonical messages losslessly so the next turn rendering still attributes the call to the assistant and its result to the tool role. Tools array is empty because the server-side exchange is already closed; this request is just continuing the conversation.",
+  "id": "req_g24_continuation_001",
+  "messages": [
+    {
+      "role": "user",
+      "content": "what legionio tools do you have available?"
+    },
+    {
+      "role": "assistant",
+      "content": "I called the legion_list_all_tools tool.",
+      "tool_calls": [
+        {
+          "id": "call_legion_001",
+          "name": "legion_list_all_tools",
+          "arguments": {"filter": "all"},
+          "source": "registry",
+          "status": "success",
+          "result": "tools: legion_list_all_tools, legion_apollo_search"
+        }
+      ]
+    },
+    {
+      "role": "tool",
+      "tool_call_id": "call_legion_001",
+      "content": "tools: legion_list_all_tools, legion_apollo_search"
+    },
+    {
+      "role": "user",
+      "content": "thanks — anything else?"
+    }
+  ],
+  "system": null,
+  "tools": null,
+  "params": null,
+  "thinking": null,
+  "stream": false,
+  "conversation_id": "conv_g24_001",
+  "routing": {},
+  "metadata": {
+    "g24": "continuation"
+  }
+}

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

@@ -0,0 +1,29 @@
+{
+  "description": "G24 — server-executed LegionIO tool. The provider returned tool_use, the executor ran the tool registry-side, and the canonical response carries both the call AND its result so client translators can surface it as a completed exchange (Claude: server_tool_use+server_tool_result, Codex: completed function_call+function_call_output non-actionable). stop_reason is end_turn because the server-side exchange is closed by the time the canonical response is built.",
+  "text": "I called the legion_list_all_tools tool and here is the list.",
+  "thinking": null,
+  "tool_calls": [
+    {
+      "id": "call_legion_001",
+      "exchange_id": "exch_legion_001",
+      "name": "legion_list_all_tools",
+      "arguments": {
+        "filter": "all"
+      },
+      "source": "registry",
+      "status": "success",
+      "result": "tools: legion_list_all_tools, legion_apollo_search, legion_runner_dispatch",
+      "duration_ms": 42
+    }
+  ],
+  "usage": {
+    "input_tokens": 50,
+    "output_tokens": 22
+  },
+  "stop_reason": "end_turn",
+  "model": "test-model-1",
+  "routing": {},
+  "metadata": {
+    "g24": true
+  }
+}