lex-llm 0.7.6 → 0.8.4

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

@@ -1,191 +1,88 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require_relative '../conformance/conformance'
 
 RSpec.describe Legion::Extensions::Llm::Canonical::ToolCall do
-  describe '.build' do
-    it 'creates a tool call with required fields' do
-      tc = described_class.build(name: 'search', arguments: { query: 'test' })
-
-      expect(tc.name).to eq('search')
-      expect(tc.arguments).to eq({ query: 'test' })
-      expect(tc.id).to start_with('call_')
-      expect(tc.arguments).to be_a(Hash)
-    end
-
-    it 'generates a random id' do
-      tc1 = described_class.build(name: 'search')
-      tc2 = described_class.build(name: 'search')
-
-      expect(tc1.id).not_to eq(tc2.id)
-    end
-
-    it 'accepts all fields' do
-      tc = described_class.build(
-        id: 'call-1',
-        exchange_id: 'ex-1',
-        name: 'search',
-        arguments: { query: 'test' },
-        source: :registry,
-        status: :pending,
-        data_handling_classification: :public,
-        policy_decision: :allowed
-      )
-
-      expect(tc.id).to eq('call-1')
-      expect(tc.exchange_id).to eq('ex-1')
-      expect(tc.source).to eq(:registry)
-      expect(tc.status).to eq(:pending)
-      expect(tc.data_handling_classification).to eq(:public)
-      expect(tc.policy_decision).to eq(:allowed)
-    end
-
-    it 'defaults arguments to empty hash' do
-      tc = described_class.build(name: 'search')
-
-      expect(tc.arguments).to eq({})
-    end
+  let(:type_class) { described_class }
+  let(:auto_generated_members) { [:id] }
+  let(:type_source) do
+    {
+      id: 'call_1',
+      name: 'get_weather',
+      arguments: { location: 'San Francisco' },
+      source: 'client',
+      status: 'pending',
+      category: 'weather',
+      metadata: { origin: 'model' }
+    }
   end
 
-  describe '.from_hash' do
-    it 'parses from hash with symbol keys' do
-      tc = described_class.from_hash(
-        id: 'call-1',
-        name: 'search',
-        arguments: { query: 'test' },
-        source: :registry
-      )
+  it_behaves_like 'a canonical type'
 
-      expect(tc.id).to eq('call-1')
-      expect(tc.name).to eq('search')
-      expect(tc.arguments).to eq({ query: 'test' })
-      expect(tc.source).to eq(:registry)
+  describe 'H1 — .new is as strict as the factories' do
+    it 'rejects a poison source enum' do
+      expect { described_class.new(name: 'x', source: :bogus) }
+        .to raise_error(ArgumentError, /Invalid source: :bogus/)
     end
 
-    it 'normalizes string source to symbol' do
-      tc = described_class.from_hash(name: 'search', source: 'registry')
-
-      expect(tc.source).to eq(:registry)
-    end
-
-    it 'normalizes string status to symbol' do
-      tc = described_class.from_hash(name: 'search', status: 'success')
-
-      expect(tc.status).to eq(:success)
-    end
-
-    it 'parses JSON string arguments to symbol keys per Legion::JSON convention' do
-      tc = described_class.from_hash(
-        name: 'search',
-        arguments: '{"query":"test","limit":10}'
-      )
-
-      expect(tc.arguments).to eq({ query: 'test', limit: 10 })
-    end
-
-    it 'handles string keys' do
-      tc = described_class.from_hash('name' => 'search', 'arguments' => '{}')
-
-      expect(tc.name).to eq('search')
-      expect(tc.arguments).to eq({})
-    end
-
-    it 'returns nil for nil source' do
-      expect(described_class.from_hash(nil)).to be_nil
-    end
-  end
-
-  describe '#with_result' do
-    it 'returns a new tool call with result' do
-      tc = described_class.build(name: 'search', source: :registry)
-      result_tc = tc.with_result(result: { hits: 5 }, status: :success, duration_ms: 100)
-
-      expect(result_tc.result).to eq({ hits: 5 })
-      expect(result_tc.status).to eq(:success)
-      expect(result_tc.duration_ms).to eq(100)
-      expect(result_tc.finished_at).to be_a(Time)
-    end
-
-    it 'sets error on error status' do
-      tc = described_class.build(name: 'search')
-      result_tc = tc.with_result(result: 'not found', status: :error)
-
-      expect(result_tc.error).to eq('not found')
-      expect(result_tc.status).to eq(:error)
+    it 'rejects JSON-string arguments (Hash only, O03a)' do
+      expect { described_class.new(name: 'x', arguments: '{"a":1}') }
+        .to raise_error(ArgumentError, /arguments expected Hash, got String/)
     end
   end
 
-  describe 'predicates' do
-    it 'identifies successful calls' do
-      tc = described_class.build(name: 'search', status: :success)
-      expect(tc.success?).to be true
-      expect(tc.error?).to be false
+  describe 'T5 — enum law (declared enums enforced in both factories)' do
+    it 'validates source against SOURCE_VALUES' do
+      expect { described_class.build(name: 'x', source: 'client') }.not_to raise_error
+      expect(described_class.build(name: 'x', source: 'client').source).to eq(:client)
+      expect { described_class.build(name: 'x', source: :bogus) }
+        .to raise_error(ArgumentError, /Invalid source: :bogus/)
+      expect { described_class.from_hash(name: 'x', source: 'nope') }
+        .to raise_error(ArgumentError, /Invalid source: :nope/)
     end
 
-    it 'identifies error calls' do
-      tc = described_class.build(name: 'search', status: :error)
-      expect(tc.error?).to be true
-      expect(tc.success?).to be false
+    it 'validates status against STATUS_VALUES' do
+      expect(described_class.build(name: 'x', status: 'running').status).to eq(:running)
+      expect { described_class.build(name: 'x', status: :finished) }
+        .to raise_error(ArgumentError, /Invalid status: :finished/)
+      expect { described_class.from_hash(name: 'x', status: 'done') }
+        .to raise_error(ArgumentError, /Invalid status: :done/)
     end
   end
 
-  describe '#to_h' do
-    it 'serializes to compact hash' do
-      tc = described_class.build(name: 'search', arguments: { query: 'test' })
-      hash = tc.to_h
-
-      expect(hash).to include(id: tc.id, name: 'search', arguments: { query: 'test' })
+  describe 'O03a — arguments Hash only' do
+    it 'does not parse JSON-string arguments (the parse + rescue are deleted)' do
+      expect { described_class.build(name: 'x', arguments: '{"a":1}') }
+        .to raise_error(ArgumentError, /arguments expected Hash, got String/)
+      expect { described_class.from_hash(name: 'x', arguments: '{\"a\":1}') }
+        .to raise_error(ArgumentError, /arguments expected Hash, got String/)
     end
-  end
-
-  describe '#to_audit_hash' do
-    it 'includes compliance fields' do
-      tc = described_class.build(
-        name: 'search',
-        source: :registry,
-        data_handling_classification: :public,
-        policy_decision: :allowed
-      )
-      hash = tc.to_audit_hash
 
-      expect(hash).to include(
-        name: 'search',
-        source: :registry,
-        data_handling_classification: :public,
-        policy_decision: :allowed
-      )
+    it 'defaults nil arguments to {} (documented no-arguments default)' do
+      expect(described_class.build(name: 'x').arguments).to eq({})
+      expect(described_class.from_hash(name: 'x').arguments).to eq({})
     end
   end
 
-  describe 'SOURCE_VALUES' do
-    it 'includes all expected source types' do
-      expect(described_class::SOURCE_VALUES).to eq(%i[client registry special extension mcp])
-    end
-  end
+  describe 'with_result (canonical mutation-free update)' do
+    it 'attaches the result and normalizes error' do
+      tc = described_class.build(name: 'x', id: 'c1', status: 'running')
+      done = tc.with_result(result: 'ok', status: :success, duration_ms: 12)
+      expect(done.result).to eq('ok')
+      expect(done.status).to eq(:success)
+      expect(done.error).to be_nil
+      expect(done.success?).to be(true)
 
-  describe 'STATUS_VALUES' do
-    it 'includes all expected status types' do
-      expect(described_class::STATUS_VALUES).to eq(%i[pending running success error])
+      failed = tc.with_result(result: 'boom', status: :error)
+      expect(failed.error).to eq('boom')
+      expect(failed.error?).to be(true)
     end
-  end
-
-  describe 'round-trip' do
-    it 'preserves values through from_hash/to_h' do
-      original = {
-        id: 'call-1',
-        name: 'search',
-        arguments: { query: 'test' },
-        source: 'registry',
-        status: 'pending'
-      }
-      tc = described_class.from_hash(original)
-      serialized = tc.to_h
 
-      expect(serialized[:id]).to eq('call-1')
-      expect(serialized[:name]).to eq('search')
-      expect(serialized[:arguments]).to eq({ query: 'test' })
-      expect(serialized[:source]).to eq(:registry)
-      expect(serialized[:status]).to eq(:pending)
+    it 'validates the result status enum' do
+      tc = described_class.build(name: 'x', id: 'c1', status: 'running')
+      expect { tc.with_result(result: 'r', status: :bogus) }
+        .to raise_error(ArgumentError, /Invalid status: :bogus/)
     end
   end
 end

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

@@ -1,221 +1,85 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require_relative '../conformance/conformance'
 
 RSpec.describe Legion::Extensions::Llm::Canonical::ToolDefinition do
-  describe '.build' do
-    it 'creates a tool definition with name and description' do
-      tool = described_class.build(name: 'search', description: 'Search the web')
-
-      expect(tool.name).to eq('search')
-      expect(tool.description).to eq('Search the web')
-      expect(tool.parameters).to eq(type: 'object', properties: {})
-      expect(tool.source).to eq({ type: :builtin })
-    end
-
-    it 'accepts parameters and source' do
-      tool = described_class.build(
-        name: 'search',
-        description: 'Search',
-        parameters: { type: 'object', properties: { query: { type: 'string' } } },
-        source: { type: :registry }
-      )
-
-      expect(tool.parameters).to eq({ type: 'object', properties: { query: { type: 'string' } } })
-      expect(tool.source).to eq({ type: :registry })
-    end
-
-    it 'sanitizes tool names' do
-      tool = described_class.build(name: 'My.Tool.Name!', description: 'test')
-
-      expect(tool.name).to eq('My_Tool_Name')
-    end
-
-    it 'truncates long tool names' do
-      long_name = 'a' * 100
-      tool = described_class.build(name: long_name)
-
-      expect(tool.name.length).to eq(64)
-    end
-
-    it 'provides fallback name for empty input' do
-      tool = described_class.build(name: '')
-
-      expect(tool.name).to eq('tool')
-    end
-
-    it 'converts nil description to empty string' do
-      tool = described_class.build(name: 'search')
-
-      expect(tool.description).to eq('')
-    end
+  let(:type_class) { described_class }
+  let(:auto_generated_members) { [] }
+  let(:type_source) do
+    {
+      name: 'get_weather',
+      description: 'Get the weather',
+      parameters: { type: 'object', properties: { location: { type: 'string' } } },
+      source: { type: :registry, tool_class: 'WeatherTool' },
+      metadata: { origin: 'client' }
+    }
   end
 
-  describe '.from_hash' do
-    it 'parses from hash with symbol keys' do
-      tool = described_class.from_hash({ name: 'search', description: 'Search', parameters: { type: 'object' } })
-
-      expect(tool.name).to eq('search')
-      expect(tool.description).to eq('Search')
-      expect(tool.parameters).to eq({ type: 'object' })
-    end
-
-    it 'parses from hash with string keys' do
-      tool = described_class.from_hash({ 'name' => 'search', 'description' => 'Search' })
-
-      expect(tool.name).to eq('search')
-      expect(tool.description).to eq('Search')
-    end
-
-    it 'accepts input_schema as alias for parameters' do
-      tool = described_class.from_hash({ name: 'search', input_schema: { type: 'object' } })
-
-      expect(tool.parameters).to eq({ type: 'object' })
-    end
-
-    it 'accepts source parameter' do
-      tool = described_class.from_hash({ name: 'search', source: { type: :extension } })
-
-      expect(tool.source).to eq({ type: :extension })
-    end
-
-    it 'overrides source with keyword arg' do
-      tool = described_class.from_hash(
-        { name: 'search', source: { type: :builtin } },
-        source: { type: :override }
-      )
+  it_behaves_like 'a canonical type'
 
-      expect(tool.source).to eq({ type: :override })
+  describe 'O03a — no input_schema alias' do
+    it 'does not translate input_schema (it folds into metadata)' do
+      td = described_class.from_hash(name: 'x', input_schema: { type: 'object', properties: {} })
+      expect(td.parameters).to eq(type: 'object', properties: {})
+      expect(td.metadata).to eq(input_schema: { type: 'object', properties: {} })
     end
   end
 
-  describe '.from_registry_entry' do
-    it 'creates from registry entry with tool_class' do
-      entry = {
-        name: 'ruby',
-        description: 'Run Ruby code',
-        input_schema: { type: 'object' },
-        tool_class: 'RubyTool',
-        extension: 'legion-code',
-        runner: 'RubyRunner',
-        function: :execute
-      }
-      tool = described_class.from_registry_entry(entry)
-
-      expect(tool.name).to eq('ruby')
-      expect(tool.description).to eq('Run Ruby code')
-      expect(tool.parameters).to eq({ type: 'object' })
-      expect(tool.source[:type]).to eq(:registry)
-      expect(tool.source[:extension]).to eq('legion-code')
-    end
-
-    it 'creates from registry entry without tool_class' do
-      entry = {
-        name: 'custom',
-        description: 'Custom tool',
-        parameters: { type: 'object', properties: { name: { type: 'string' } } },
-        extension: 'custom-ext'
-      }
-      tool = described_class.from_registry_entry(entry)
-
-      expect(tool.source[:type]).to eq(:extension)
+  describe 'L3 — no coercion of non-Hash input' do
+    it 'raises on non-Hash from_hash input (the {} fabrication is deleted)' do
+      expect { described_class.from_hash(nil) }
+        .to raise_error(ArgumentError, /expected Hash, got NilClass/)
+      expect { described_class.from_hash('raw') }
+        .to raise_error(ArgumentError, /expected Hash, got String/)
     end
   end
 
-  describe '.sanitize_tool_name' do
-    it 'replaces dots with underscores' do
-      expect(described_class.sanitize_tool_name('my.tool')).to eq('my_tool')
+  describe 'schema normalization (frozen inference rules)' do
+    it 'defaults missing/empty parameters to an empty object schema' do
+      expect(described_class.build(name: 'x').parameters).to eq(type: 'object', properties: {})
     end
 
-    it 'removes special characters' do
-      expect(described_class.sanitize_tool_name('my-tool!@#')).to eq('my-tool')
+    it 'wraps bare property maps in an object schema' do
+      td = described_class.build(name: 'x', parameters: { a: { type: 'string' } })
+      expect(td.parameters).to eq(type: 'object', properties: { a: { type: 'string' } })
     end
 
-    it 'preserves alphanumeric, underscores, and hyphens' do
-      expect(described_class.sanitize_tool_name('my-tool_123')).to eq('my-tool_123')
-    end
-  end
-
-  describe '#to_h' do
-    it 'serializes to hash with name, description, parameters' do
-      tool = described_class.build(
-        name: 'search',
-        description: 'Search the web',
-        parameters: { type: 'object' }
-      )
-      hash = tool.to_h
-
-      expect(hash).to eq(
-        name: 'search',
-        description: 'Search the web',
-        parameters: { type: 'object' }
-      )
-    end
-
-    it 'omits nil values' do
-      tool = described_class.new('search', '', nil, nil)
-      hash = tool.to_h
-
-      expect(hash).to eq(name: 'search')
+    it 'keeps explicit type and composite schemas as-is' do
+      expect(described_class.build(name: 'x', parameters: { type: 'string' }).parameters)
+        .to eq(type: 'string')
+      expect(described_class.build(name: 'x', parameters: { oneOf: [] }).parameters)
+        .to eq(oneOf: [])
     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'])
+  describe 'M5 — the name is authoritative (no rewrite, no fabrication)' do
+    it 'preserves the client/registry name verbatim (dialect rules live at the provider edge)' do
+      expect(described_class.build(name: 'get.weather').name).to eq('get.weather')
+      expect(described_class.build(name: 'a' * 80).name).to eq('a' * 80)
+      expect(described_class).not_to respond_to(:sanitize_tool_name)
     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)
+    it 'raises on a missing or empty name (the "tool" fabrication is deleted)' do
+      expect { described_class.build(name: nil) }
+        .to raise_error(ArgumentError, /name must be a non-empty String/)
+      expect { described_class.build(name: '') }
+        .to raise_error(ArgumentError, /name must be a non-empty String/)
+      expect { described_class.from_hash({}) }
+        .to raise_error(ArgumentError, /name must be a non-empty String/)
     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: {})
+    it 'does not fabricate a source (explicit or absent, never laundered to builtin)' do
+      expect(described_class.build(name: 'x').source).to be_nil
+      expect(described_class.build(name: 'x', source: { type: :client }).source).to eq(type: :client)
+      expect { described_class.build(name: 'x', source: 'client') }
+        .to raise_error(ArgumentError, /source expected Hash/)
     end
   end
 
-  describe 'round-trip' do
-    it 'preserves values through from_hash/to_h' do
-      original = { name: 'search', description: 'Search', parameters: { type: 'object' } }
-      tool = described_class.from_hash(original)
-      serialized = tool.to_h
-
-      expect(serialized[:name]).to eq('search')
-      expect(serialized[:description]).to eq('Search')
-      expect(serialized[:parameters]).to eq({ type: 'object' })
-    end
+  it 'builds from keyword args with defaults (empty description, absent source)' do
+    td = described_class.build(name: 'x')
+    expect(td.description).to eq('')
+    expect(td.source).to be_nil
   end
 end

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

@@ -3,81 +3,40 @@
 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
+  let(:tool_definition) do
     Legion::Extensions::Llm::Canonical::ToolDefinition.build(
-      name: 'get_weather', description: 'Weather lookup', parameters: full_schema
+      name: 'get_weather',
+      description: 'Get the weather',
+      parameters: { type: 'object', properties: { location: { type: 'string' } } }
     )
   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
+  it 'extracts the normalized schema from a ToolDefinition' do
+    expect(described_class.extract(tool_definition)).to eq(
+      type: 'object', properties: { location: { type: 'string' } }
+    )
   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
+  it 'returns the tool name and description' do
+    expect(described_class.tool_name(tool_definition)).to eq('get_weather')
+    expect(described_class.tool_description(tool_definition)).to eq('Get the weather')
   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)
+  describe '04 §6 — ToolDefinition ONLY (dual-shape accessors deleted)' do
+    it 'raises on a raw Hash' do
+      expect { described_class.extract({ name: 'x' }) }
+        .to raise_error(ArgumentError, /expected Canonical::ToolDefinition, got Hash/)
+      expect { described_class.tool_name({ name: 'x' }) }
+        .to raise_error(ArgumentError, /expected Canonical::ToolDefinition, got Hash/)
+      expect { described_class.tool_description({ name: 'x' }) }
+        .to raise_error(ArgumentError, /expected Canonical::ToolDefinition, got Hash/)
+    end
+
+    it 'raises on nil and other wrong classes' do
+      expect { described_class.extract(nil) }
+        .to raise_error(ArgumentError, /expected Canonical::ToolDefinition, got NilClass/)
+      expect { described_class.tool_name('str') }
+        .to raise_error(ArgumentError, /expected Canonical::ToolDefinition, got String/)
     end
   end
 end