lex-llm 0.7.6 → 0.8.4

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

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'tempfile'
-
-RSpec.describe Legion::Extensions::Llm::Models do
-  subject(:models) { described_class.new([chat_model, embedding_model]) }
-
-  include_context 'with fake llm provider'
-
-  let(:chat_model) do
-    Legion::Extensions::Llm::Model::Info.from_hash(
-      id: 'fake-chat-model',
-      name: 'Fake Chat Model',
-      provider: 'fake_llm',
-      family: 'fake',
-      modalities: { input: ['text'], output: ['text'] },
-      capabilities: %w[function_calling structured_output streaming]
-    )
-  end
-
-  let(:embedding_model) do
-    Legion::Extensions::Llm::Model::Info.from_hash(
-      id: 'fake-embedding-model',
-      name: 'Fake Embedding Model',
-      provider: 'fake_llm',
-      family: 'fake',
-      modalities: { input: ['text'], output: ['embeddings'] },
-      capabilities: ['embedding']
-    )
-  end
-
-  after do
-    described_class.instance_variable_set(:@instance, nil)
-  end
-
-  it 'filters models by provider and usage type' do
-    expect(models.by_provider(:fake_llm).map(&:id)).to eq(%w[fake-chat-model fake-embedding-model])
-    expect(models.chat_models.map(&:id)).to eq(['fake-chat-model'])
-    expect(models.embedding_models.map(&:id)).to eq(['fake-embedding-model'])
-  end
-
-  it 'resolves models through the provider registry' do
-    allow(described_class).to receive(:instance).and_return(models)
-
-    model, provider = described_class.resolve('fake-chat-model')
-
-    expect(model.id).to eq('fake-chat-model')
-    expect(provider).to be_a(SpecSupport::FakeLLMProvider)
-  end
-
-  it 'supports provider-specific model id normalization through provider hooks' do
-    normalizing_class = Class.new(SpecSupport::FakeLLMProvider) do
-      def self.resolve_model_id(model_id, config: nil) # rubocop:disable Lint/UnusedMethodArgument
-        model_id == 'alias-model' ? 'fake-chat-model' : model_id
-      end
-    end
-
-    # Temporarily define a namespace module so scan_provider_classes can find it
-    mod = Module.new do
-      const_set(:PROVIDER_FAMILY, :normalizing_fake)
-    end
-    mod.define_singleton_method(:provider_class) { normalizing_class }
-    stub_const('Legion::Extensions::Llm::NormalizingFakeProvider', mod)
-
-    normalized = Legion::Extensions::Llm::Model::Info.from_hash(
-      id: 'fake-chat-model',
-      name: 'Normalized',
-      provider: 'normalizing_fake',
-      modalities: { output: ['text'] }
-    )
-    registry = described_class.new([normalized])
-
-    expect(registry.find('alias-model', :normalizing_fake).id).to eq('fake-chat-model')
-  end
-
-  it 'raises when a model exists but its provider extension is not registered' do
-    registry = described_class.new([
-                                     Legion::Extensions::Llm::Model::Info.from_hash(
-                                       id: 'orphan-model',
-                                       name: 'Orphan',
-                                       provider: 'missing_provider'
-                                     )
-                                   ])
-    allow(described_class).to receive(:instance).and_return(registry)
-
-    expect do
-      described_class.resolve('orphan-model')
-    end.to raise_error(Legion::Extensions::Llm::Error, /Unknown provider/)
-  end
-
-  it 'saves and loads model metadata as Legion JSON' do
-    temp_file = Tempfile.new(['models', '.json'])
-    models.save_to_json(temp_file.path)
-
-    parsed = Legion::JSON.parse(File.read(temp_file.path), symbolize_names: false)
-    expect(parsed.map { |model| model['id'] }).to eq(%w[fake-chat-model fake-embedding-model])
-
-    loaded = described_class.read_from_json(temp_file.path)
-    expect(loaded.map(&:id)).to eq(%w[fake-chat-model fake-embedding-model])
-  ensure
-    temp_file&.close!
-  end
-end

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Legion::Extensions::Llm::RegistryEventBuilder do
-  subject(:builder) { described_class.new(provider_family: :ollama) }
-
-  describe '#provider_family' do
-    it 'normalizes to a downcased symbol' do
-      b = described_class.new(provider_family: 'Anthropic')
-      expect(b.provider_family).to eq(:anthropic)
-    end
-  end
-
-  describe '#model_available' do
-    let(:model) do
-      Legion::Extensions::Llm::Model::Info.from_hash(
-        id: 'llama-3.1-8b',
-        name: 'Llama 3.1 8B',
-        provider: 'ollama',
-        capabilities: %w[completion streaming],
-        modalities: { input: %w[text], output: %w[text] },
-        context_window: 128_000,
-        max_output_tokens: 8192
-      )
-    end
-
-    let(:readiness) { { ready: true, configured: true } }
-
-    it 'builds a RegistryEvent with offering data' do
-      event = builder.model_available(model, readiness: readiness)
-      expect(event).to be_a(Legion::Extensions::Llm::Routing::RegistryEvent)
-      expect(event.event_type).to eq(:offering_available)
-      expect(event.offering.model).to eq('llama-3.1-8b')
-      expect(event.offering.provider_family).to eq(:ollama)
-    end
-
-    it 'includes model health from readiness' do
-      event = builder.model_available(model, readiness: readiness)
-      expect(event.health[:ready]).to be true
-      expect(event.health[:status]).to eq(:available)
-    end
-
-    it 'includes extension metadata' do
-      event = builder.model_available(model, readiness: readiness)
-      expect(event.metadata[:extension]).to eq(:llm_ollama)
-      expect(event.metadata[:provider]).to eq(:ollama)
-    end
-  end
-
-  describe '#readiness' do
-    it 'builds an available event when ready' do
-      event = builder.readiness({ ready: true, configured: true })
-      expect(event.event_type).to eq(:offering_available)
-    end
-
-    it 'builds an unavailable event when not ready' do
-      event = builder.readiness({ ready: false, configured: true })
-      expect(event.event_type).to eq(:offering_unavailable)
-    end
-
-    it 'preserves error details from health' do
-      event = builder.readiness({ ready: false, health: { error: 'ConnectionRefused', message: 'refused' } })
-      expect(event.health[:error_class]).to eq('ConnectionRefused')
-      expect(event.health[:error]).to eq('refused')
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Legion::Extensions::Llm::RegistryPublisher do
-  subject(:publisher) { described_class.new(provider_family: :ollama, builder: builder) }
-
-  let(:builder) { instance_double(Legion::Extensions::Llm::RegistryEventBuilder) }
-
-  describe '#app_id' do
-    it 'includes the provider family' do
-      expect(publisher.app_id).to eq('lex-llm-ollama')
-    end
-  end
-
-  describe '#provider_family' do
-    it 'normalizes to a downcased symbol' do
-      pub = described_class.new(provider_family: 'Anthropic', builder: builder)
-      expect(pub.provider_family).to eq(:anthropic)
-    end
-  end
-end

data/spec/legion/extensions/llm/responses/response_objects_spec.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# rubocop:disable RSpec/DescribeClass
-RSpec.describe 'LLM normalized response objects' do
-  let(:unsafe_metadata) do
-    {
-      reasoning_content: 'metadata secret',
-      reasoning: 'metadata reasoning',
-      thinking_text: 'metadata thinking',
-      raw: { reasoning_content: 'nested raw secret' },
-      'raw-response' => { reasoning_content: 'hyphen raw secret' },
-      'provider-body' => { thinking_text: 'hyphen body secret' },
-      vendor: 'vllm'
-    }
-  end
-  let(:unsafe_raw) { { 'choices' => [{ 'message' => { 'content' => '<think>raw secret</think>visible' } }] } }
-
-  it 'serializes chat responses without raw provider thinking fields' do
-    response = Legion::Extensions::Llm::Responses::ChatResponse.new(
-      content: "<think>tag secret</think>\nvisible",
-      metadata: unsafe_metadata,
-      raw: unsafe_raw
-    )
-
-    payload = response.to_h
-    encoded = Legion::JSON.dump(payload)
-
-    expect(payload).to eq(content: 'visible', metadata: { vendor: 'vllm' })
-    expect(encoded).not_to include('reasoning', 'reasoning_content', 'thinking_text', '<think>', 'raw secret',
-                                   'nested raw secret', 'hyphen raw secret', 'hyphen body secret')
-    expect(response.to_internal_h).to include(
-      thinking: 'metadata secretmetadata reasoningmetadata thinkingtag secret',
-      metadata: unsafe_metadata,
-      raw: unsafe_raw
-    )
-  end
-
-  it 'serializes stream chunks without raw provider thinking fields' do
-    chunk = Legion::Extensions::Llm::Responses::StreamChunk.new(
-      content: "<think>tag secret</think>\nvisible",
-      metadata: unsafe_metadata,
-      raw: unsafe_raw
-    )
-
-    payload = chunk.to_h
-    encoded = Legion::JSON.dump(payload)
-
-    expect(payload).to eq(content: 'visible', metadata: { vendor: 'vllm' })
-    expect(encoded).not_to include('reasoning', 'reasoning_content', 'thinking_text', '<think>', 'raw secret',
-                                   'nested raw secret', 'hyphen raw secret', 'hyphen body secret')
-    expect(chunk.to_internal_h).to include(
-      thinking: 'metadata secretmetadata reasoningmetadata thinkingtag secret',
-      metadata: unsafe_metadata,
-      raw: unsafe_raw
-    )
-  end
-
-  it 'serializes embedding responses without raw provider payloads' do
-    response = Legion::Extensions::Llm::Responses::EmbeddingResponse.new(
-      vectors: [[0.1]],
-      model: 'embed',
-      metadata: unsafe_metadata,
-      raw: unsafe_raw
-    )
-
-    payload = response.to_h
-
-    expect(payload).to eq(vectors: [[0.1]], model: 'embed', metadata: { vendor: 'vllm' })
-    expect(Legion::JSON.dump(payload)).not_to include('raw secret')
-    expect(response.to_internal_h).to include(metadata: unsafe_metadata, raw: unsafe_raw)
-  end
-end
-# rubocop:enable RSpec/DescribeClass

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

@@ -1,281 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Legion::Extensions::Llm::Routing::ModelOffering do
-  subject(:offering) do
-    described_class.new(
-      provider_family: :ollama,
-      instance_id: :'macbook-m4-max',
-      transport: :rabbitmq,
-      model: 'qwen3.6:27b-q4_K_M',
-      capabilities: %i[chat tools thinking],
-      limits: { context_window: 32_768, max_output_tokens: 8192 },
-      policy_tags: %i[phi_allowed internal_only]
-    )
-  end
-
-  it 'normalizes provider-neutral offering metadata' do
-    expect(offering).to have_attributes(
-      offering_id: 'ollama:macbook-m4-max:inference:qwen3-6-27b-q4-k-m',
-      provider_family: :ollama,
-      provider_instance: :'macbook-m4-max',
-      instance_id: :'macbook-m4-max',
-      transport: :rabbitmq,
-      tier: :fleet,
-      model: 'qwen3.6:27b-q4_K_M',
-      canonical_model_alias: 'qwen3.6:27b-q4_K_M',
-      usage_type: :inference
-    )
-    expect(offering.capabilities).to eq(%i[chat tools thinking])
-    expect(offering.context_window).to eq(32_768)
-  end
-
-  it 'accepts expanded contract fields while preserving instance_id compatibility' do
-    expanded = described_class.new(
-      offering_id: 'azure:gpt4o-prod',
-      provider_family: :azure_foundry,
-      model_family: :openai,
-      provider_instance: :eastus,
-      model: 'gpt4o-prod',
-      canonical_model_alias: 'gpt-4o',
-      routing_metadata: { region: 'eastus', deployment: 'gpt4o-prod' },
-      capabilities: %i[chat tools]
-    )
-
-    expect(expanded).to have_attributes(
-      offering_id: 'azure:gpt4o-prod',
-      provider_family: :azure_foundry,
-      model_family: :openai,
-      provider_instance: :eastus,
-      instance_id: :eastus,
-      model: 'gpt4o-prod',
-      canonical_model_alias: 'gpt-4o',
-      routing_metadata: { region: 'eastus', deployment: 'gpt4o-prod' }
-    )
-    expect(expanded.to_h).to include(
-      provider_instance: :eastus,
-      instance_id: :eastus,
-      canonical_model_alias: 'gpt-4o',
-      routing_metadata: { region: 'eastus', deployment: 'gpt4o-prod' }
-    )
-  end
-
-  it 'lifts model family and aliases from legacy metadata' do
-    legacy = described_class.new(
-      provider_family: :bedrock,
-      instance_id: :'us-east-1',
-      model: 'anthropic.claude-3-haiku-20240307-v1:0',
-      metadata: { model_family: :anthropic, alias: 'claude-3-haiku' }
-    )
-
-    expect(legacy.model_family).to eq(:anthropic)
-    expect(legacy.canonical_model_alias).to eq('claude-3-haiku')
-    expect(legacy.model_alias?('claude-3-haiku')).to be true
-    expect(legacy.model_alias?('anthropic.claude-3-haiku-20240307-v1:0')).to be true
-  end
-
-  it 'checks route eligibility without provider-specific code' do
-    expect(
-      offering.eligible_for?(
-        usage_type: :inference,
-        required_capabilities: %i[tools thinking],
-        min_context_window: 32_000,
-        policy_tags: [:phi_allowed]
-      )
-    ).to be true
-
-    expect(offering.eligible_for?(min_context_window: 65_536)).to be false
-    expect(offering.eligible_for?(required_capabilities: [:vision])).to be false
-  end
-
-  it 'treats legacy function-calling capability names as tools support' do
-    legacy_tools = described_class.new(
-      provider_family: :vllm,
-      model: 'qwen-tools',
-      capabilities: %i[chat function_calling]
-    )
-
-    expect(legacy_tools.capabilities).to include(:tools)
-    expect(legacy_tools.capabilities).not_to include(:function_calling)
-    expect(legacy_tools.eligible_for?(required_capabilities: [:tools])).to be true
-  end
-
-  it 'treats disabled offerings as ineligible' do
-    disabled = described_class.new(
-      provider_family: :ollama,
-      instance_id: :local,
-      model: 'qwen',
-      metadata: { enabled: false }
-    )
-
-    expect(disabled).not_to be_enabled
-    expect(disabled.eligible_for?).to be false
-  end
-
-  it 'generates clean fleet inference lane keys with context windows' do
-    expect(offering.lane_key).to eq('llm.fleet.inference.qwen3-6-27b-q4-k-m.ctx32768')
-  end
-
-  it 'uses canonical model aliases for fleet lanes when provider deployments hide the base model' do
-    deployment = described_class.new(
-      provider_family: :azure_foundry,
-      provider_instance: :default,
-      model: 'gpt4o-prod',
-      canonical_model_alias: 'gpt-4o',
-      limits: { context_window: 128_000 }
-    )
-
-    expect(deployment.lane_key).to eq('llm.fleet.inference.gpt-4o.ctx128000')
-  end
-
-  it 'generates embedding lanes without context suffixes' do
-    embedding = described_class.new(
-      provider_family: :ollama,
-      instance_id: :'gpu-01',
-      transport: :rabbitmq,
-      model: 'nomic-embed-text:latest',
-      usage_type: :embed,
-      capabilities: [:embedding]
-    )
-
-    expect(embedding).to be_embedding
-    expect(embedding.lane_key).to eq('llm.fleet.embed.nomic-embed-text-latest')
-  end
-
-  it 'can include an eligibility fingerprint when lanes need stricter matching' do
-    key = offering.lane_key(include_fingerprint: true)
-
-    expect(key).to match(/\Allm\.fleet\.inference\.qwen3-6-27b-q4-k-m\.ctx32768\.elig\.[0-9a-f]{10}\z/)
-    expect(offering.eligibility_fingerprint).to eq(key.split('.').last)
-  end
-
-  it 'normalizes string numeric limits from JSON-backed settings' do
-    string_limits = described_class.new(
-      provider_family: :ollama,
-      model: 'qwen',
-      limits: { context_window: '32768', max_output_tokens: '8192' }
-    )
-
-    expect(string_limits.context_window).to eq(32_768)
-    expect(string_limits.max_output_tokens).to eq(8192)
-    expect(string_limits.eligible_for?(min_context_window: 32_000)).to be true
-  end
-
-  it 'normalizes string-keyed JSON-backed offering fields' do
-    json_offering = described_class.new(
-      'provider_family' => 'ollama',
-      'instance_id' => 'macbook-m4-max',
-      'transport' => 'rabbitmq',
-      'model' => 'nomic-embed-text',
-      'type' => 'embed',
-      'capabilities' => %w[embedding],
-      'limits' => { 'context_window' => '8192' },
-      'metadata' => { 'enabled' => true }
-    )
-
-    expect(json_offering.provider_family).to eq(:ollama)
-    expect(json_offering.instance_id).to eq(:'macbook-m4-max')
-    expect(json_offering.transport).to eq(:rabbitmq)
-    expect(json_offering.usage_type).to eq(:embedding)
-    expect(json_offering.context_window).to eq(8192)
-    expect(json_offering).to be_enabled
-  end
-
-  it 'treats string-keyed disabled metadata as ineligible' do
-    disabled = described_class.new(
-      'provider_family' => 'ollama',
-      'model' => 'qwen',
-      'metadata' => { 'enabled' => false }
-    )
-
-    expect(disabled).not_to be_enabled
-    expect(disabled.eligible_for?).to be false
-  end
-
-  it 'keeps sensitive metadata out of eligibility fingerprints' do
-    safe = described_class.new(
-      provider_family: :ollama,
-      model: 'qwen',
-      metadata: { eligibility: { endpoint_url: 'http://gpu.internal', network_boundary: :corp_lan } }
-    )
-    changed_secret = described_class.new(
-      provider_family: :ollama,
-      model: 'qwen',
-      metadata: { eligibility: { endpoint_url: 'http://other.internal', network_boundary: :corp_lan } }
-    )
-
-    expect(safe.eligibility_fingerprint).to eq(changed_secret.eligibility_fingerprint)
-  end
-
-  it 'serializes the normalized shape used by routers and registries' do
-    expect(offering.to_h).to include(
-      offering_id: 'ollama:macbook-m4-max:inference:qwen3-6-27b-q4-k-m',
-      provider_family: :ollama,
-      provider_instance: :'macbook-m4-max',
-      instance_id: :'macbook-m4-max',
-      tier: :fleet,
-      canonical_model_alias: 'qwen3.6:27b-q4_K_M',
-      usage_type: :inference,
-      limits: { context_window: 32_768, max_output_tokens: 8192 }
-    )
-  end
-
-  describe 'capability_sources' do
-    it 'accepts and exposes capability source metadata' do
-      sourced = described_class.new(
-        provider_family: :vllm,
-        provider_instance: :apollo,
-        model: 'gemma-4-12b-it',
-        capabilities: %i[streaming tools],
-        capability_sources: {
-          streaming: { value: true, source: :provider_envelope },
-          tools: { value: true, source: :instance_override },
-          embeddings: { value: false, source: :default_false }
-        }
-      )
-
-      expect(sourced.capabilities).to include(:streaming, :tools)
-      expect(sourced.capability_sources[:tools]).to eq(value: true, source: :instance_override)
-      expect(sourced.capability_sources[:embedding]).to eq(value: false, source: :default_false)
-    end
-
-    it 'includes capability_sources in to_h' do
-      sourced = described_class.new(
-        provider_family: :vllm,
-        provider_instance: :apollo,
-        model: 'gemma-4-12b-it',
-        capabilities: %i[streaming],
-        capability_sources: {
-          streaming: { value: true, source: :provider_envelope }
-        }
-      )
-
-      expect(sourced.to_h[:capability_sources]).to eq(
-        streaming: { value: true, source: :provider_envelope }
-      )
-    end
-
-    it 'normalizes string-keyed capability sources' do
-      sourced = described_class.new(
-        provider_family: :vllm,
-        model: 'test',
-        capability_sources: {
-          'streaming' => { 'value' => true, 'source' => 'provider_envelope' }
-        }
-      )
-
-      expect(sourced.capability_sources[:streaming]).to eq(value: true, source: :provider_envelope)
-    end
-
-    it 'defaults to empty hash when not provided' do
-      plain = described_class.new(
-        provider_family: :ollama,
-        model: 'test',
-        capabilities: %i[streaming]
-      )
-
-      expect(plain.capability_sources).to eq({})
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Legion::Extensions::Llm::Routing::OfferingRegistry do
-  subject(:registry) { described_class.new([chat, embedding]) }
-
-  let(:chat) do
-    Legion::Extensions::Llm::Routing::ModelOffering.new(
-      provider_family: :azure_foundry,
-      model_family: :openai,
-      provider_instance: :eastus,
-      model: 'gpt4o-prod',
-      canonical_model_alias: 'gpt-4o',
-      capabilities: %i[chat tools],
-      limits: { context_window: 128_000 }
-    )
-  end
-
-  let(:embedding) do
-    Legion::Extensions::Llm::Routing::ModelOffering.new(
-      provider_family: :bedrock,
-      model_family: :amazon,
-      instance_id: :'us-east-1',
-      model: 'amazon.titan-embed-text-v2:0',
-      canonical_model_alias: 'titan-embed-text-v2',
-      usage_type: :embedding,
-      capabilities: [:embedding]
-    )
-  end
-
-  it 'registers hashes and offerings by normalized offering_id' do
-    replacement = registry.register(
-      chat.to_h.merge(capabilities: %i[chat vision])
-    )
-
-    expect(registry.find(chat.offering_id)).to eq(replacement)
-    expect(registry.find(chat.offering_id).capabilities).to eq(%i[chat vision])
-    expect(registry.count).to eq(2)
-  end
-
-  it 'finds and filters offerings by the expanded routing contract' do
-    expect(registry.find_by_model_alias('gpt-4o')).to eq(chat)
-    expect(registry.filter(provider_family: :azure_foundry)).to eq([chat])
-    expect(registry.filter(model_family: :openai)).to eq([chat])
-    expect(registry.filter(provider_instance: :eastus)).to eq([chat])
-    expect(registry.filter(capability: :embedding)).to eq([embedding])
-    expect(registry.filter(model_alias: 'titan-embed-text-v2', usage_type: :embedding)).to eq([embedding])
-  end
-end