lex-llm 0.7.3 → 0.8.0

data/lib/legion/extensions/llm/transport/messages/registry_event.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-return unless defined?(Legion::Transport::Message)
-
-require_relative '../exchanges/llm_registry'
-
-module Legion
-  module Extensions
-    module Llm
-      module Transport
-        module Messages
-          # Publishes lex-llm RegistryEvent envelopes to the shared llm.registry exchange.
-          # Accepts a `provider_family` for constructing the app_id and routing key.
-          class RegistryEvent < ::Legion::Transport::Message
-            def initialize(event:, provider_family: nil, **options)
-              @provider_family = provider_family
-              super(**event.to_h.merge(options))
-            end
-
-            def exchange
-              Exchanges::LlmRegistry
-            end
-
-            def routing_key
-              @options[:routing_key] || "llm.registry.#{@options.fetch(:event_type)}"
-            end
-
-            def type
-              'llm.registry.event'
-            end
-
-            def app_id
-              @options[:app_id] || "lex-llm-#{@provider_family || 'unknown'}"
-            end
-
-            def persistent # rubocop:disable Naming/PredicateMethod
-              false
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Legion::Extensions::Llm::Agent do
-  include_context 'with configured Legion::Extensions::Llm'
-  include_context 'with fake llm provider'
-
-  it 'builds a configured plain chat via .chat with runtime inputs' do
-    tool_class = Class.new(Legion::Extensions::Llm::Tool) do
-      def name = 'echo_tool'
-    end
-
-    agent_class = Class.new(Legion::Extensions::Llm::Agent) do
-      model 'fake-chat-model', provider: :fake_llm, assume_model_exists: true
-      inputs :display_name
-      instructions { "Hello #{display_name}" }
-      tools { [tool_class.new] }
-      params { { max_tokens: 12 } }
-    end
-
-    chat = agent_class.chat(display_name: 'Ava')
-
-    expect(chat.messages.first.role).to eq(:system)
-    expect(chat.messages.first.content).to eq('Hello Ava')
-    expect(chat.tools.keys).to include(:echo_tool)
-    expect(chat.params).to eq(max_tokens: 12)
-  end
-
-  it 'exposes Legion::Extensions::Llm::Chat as chat in execution context for .chat' do
-    agent_class = Class.new(Legion::Extensions::Llm::Agent) do
-      model 'fake-chat-model', provider: :fake_llm, assume_model_exists: true
-      instructions { chat.class.name }
-    end
-
-    chat = agent_class.chat
-    expect(chat.messages.first.content).to eq('Legion::Extensions::Llm::Chat')
-  end
-
-  it 'raises when instructions default prompt is missing' do
-    agent_class = Class.new(Legion::Extensions::Llm::Agent) do
-      model 'fake-chat-model', provider: :fake_llm, assume_model_exists: true
-      instructions
-    end
-
-    expect { agent_class.chat }.to raise_error(Legion::Extensions::Llm::PromptNotFoundError, /Prompt file not found/)
-  end
-
-  it 'supports inline schema DSL via schema do ... end' do
-    agent_class = Class.new(Legion::Extensions::Llm::Agent) do
-      model 'fake-chat-model', provider: :fake_llm, assume_model_exists: true
-      schema do
-        string :verdict, enum: %w[pass revise]
-        string :feedback
-      end
-    end
-
-    chat = agent_class.chat
-
-    expect(chat.schema).to include(name: 'Schema', strict: true, schema: include(type: 'object'))
-    expect(chat.schema.dig(:schema, :properties)).to include(
-      verdict: include(type: 'string'),
-      feedback: include(type: 'string')
-    )
-  end
-
-  it 'supports runtime-evaluated schema blocks that return a schema value' do
-    agent_class = Class.new(Legion::Extensions::Llm::Agent) do
-      model 'fake-chat-model', provider: :fake_llm, assume_model_exists: true
-      inputs :strict
-
-      schema do
-        if strict
-          {
-            type: 'object',
-            properties: { answer: { type: 'string' } },
-            required: ['answer'],
-            additionalProperties: false
-          }
-        end
-      end
-    end
-
-    strict_chat = agent_class.chat(strict: true)
-    loose_chat = agent_class.chat(strict: false)
-
-    expect(strict_chat.schema).to include(name: 'response', strict: true, schema: include(type: 'object'))
-    expect(loose_chat.schema).to be_nil
-  end
-
-  it 'can ask using a registered provider' do
-    agent_class = Class.new(Legion::Extensions::Llm::Agent) do
-      model 'fake-chat-model', provider: :fake_llm, assume_model_exists: true
-      instructions 'Answer questions clearly.'
-    end
-
-    stub_const('SpecChatAgent', agent_class)
-
-    response = SpecChatAgent.new.ask('hello')
-    expect(response.content).to include('fake response to hello')
-    expect(response.role).to eq(:assistant)
-  end
-
-  it 'delegates add_message to the underlying chat interface' do
-    agent_class = Class.new(Legion::Extensions::Llm::Agent) do
-      model 'fake-chat-model', provider: :fake_llm, assume_model_exists: true
-    end
-
-    agent = agent_class.new
-    message = agent.add_message(role: :user, content: 'Hello')
-
-    expect(message.role).to eq(:user)
-    expect(message.content).to eq('Hello')
-    expect(agent.chat.messages.last).to eq(message)
-  end
-
-  it 'exposes messages like Legion::Extensions::Llm::Chat' do
-    agent_class = Class.new(Legion::Extensions::Llm::Agent) do
-      model 'fake-chat-model', provider: :fake_llm, assume_model_exists: true
-    end
-
-    agent = agent_class.new
-    agent.add_message(role: :user, content: 'First')
-
-    expect(agent.messages).to eq(agent.chat.messages)
-    expect(agent.messages.last.content).to eq('First')
-  end
-
-  it 'delegates callback hooks to the underlying chat' do
-    fake_chat = Class.new do
-      attr_reader :events
-
-      def initialize
-        @events = []
-      end
-
-      def on_new_message(&)
-        @events << :new_message
-        self
-      end
-
-      def on_end_message(&)
-        @events << :end_message
-        self
-      end
-
-      def on_tool_call(&)
-        @events << :tool_call
-        self
-      end
-
-      def on_tool_result(&)
-        @events << :tool_result
-        self
-      end
-    end.new
-
-    agent = Class.new(described_class).new(chat: fake_chat)
-
-    expect(agent.on_new_message { :ok }).to eq(fake_chat)
-    expect(agent.on_end_message { :ok }).to eq(fake_chat)
-    expect(agent.on_tool_call { :ok }).to eq(fake_chat)
-    expect(agent.on_tool_result { :ok }).to eq(fake_chat)
-    expect(fake_chat.events).to eq(%i[new_message end_message tool_call tool_result])
-  end
-
-  it 'supports Enumerable by delegating each to chat' do
-    fake_chat = Class.new do
-      def each(&)
-        return enum_for(:each) unless block_given?
-
-        %w[first second].each(&)
-      end
-    end.new
-
-    agent = Class.new(described_class).new(chat: fake_chat)
-    expect(agent.map(&:upcase)).to eq(%w[FIRST SECOND])
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'open3'
-require 'rbconfig'
-
-RSpec.describe Legion::Extensions::Llm::Attachment do
-  it 'supports path attachments from the public API' do
-    script = <<~'RUBY'
-      require 'legion/extensions/llm'
-
-      content = Legion::Extensions::Llm::Content.new('What is in this file?', 'spec/fixtures/ruby.txt')
-      attachment = content.attachments.first
-      puts "#{attachment.filename},#{attachment.mime_type}"
-    RUBY
-
-    stdout, stderr, status = Open3.capture3(
-      RbConfig.ruby, '-Ilib', '-e', script,
-      chdir: File.expand_path('../../../..', __dir__)
-    )
-
-    expect(status.success?).to be(true), stderr
-    expect(stdout.strip).to eq('ruby.txt,text/plain')
-  end
-end

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

@@ -1,84 +0,0 @@
-{
-  "description": "Binding SSOT v3 identity input/byte/digest fixtures. Recompute every field and digest; do not merely check a prefix. No Ruby object hash, hash-iteration order, or delimiter splitting is used anywhere.",
-  "algorithm": {
-    "frame": "binary bytes: decimal(UTF-8 byte length) + ASCII 0x3a colon + exact UTF-8 bytes",
-    "offering_id": "off:v1: + lowercase_hex(SHA256(frame(provider_family) + frame(instance_id) + frame(provider_native_key)))",
-    "lane_id": "lane:v1: + lowercase_hex(SHA256(ASCII(\"lane-v1\\u0000\") + frame(provider_family) + frame(instance_id) + frame(operation) + frame(model) + frame(offering_id)))",
-    "lane_domain_prefix_hex": "6c616e652d763100",
-    "notes": "Tier is never an identity input. provider_native_key, model, and offering_id preserve declared case."
-  },
-  "vectors": [
-    {
-      "provider_family": "vllm",
-      "instance_id": "h200",
-      "provider_native_key": "gemma4",
-      "model": "gemma4",
-      "operation": "chat",
-      "framed_hex": {
-        "provider_family": "343a766c6c6d",
-        "instance_id": "343a68323030",
-        "provider_native_key": "363a67656d6d6134",
-        "operation": "343a63686174",
-        "model": "363a67656d6d6134",
-        "offering_id": "37313a6f66663a76313a63393636373732643766386634323863323461373762653936663934653131316261313035326266303933303938663034313362353632633130353964636431"
-      },
-      "offering_hash_input_hex": "343a766c6c6d343a68323030363a67656d6d6134",
-      "expected_offering_id": "off:v1:c966772d7f8f428c24a77be96f94e111ba1052bf093098f0413b562c1059dcd1",
-      "lane_hash_input_hex": "6c616e652d763100343a766c6c6d343a68323030343a63686174363a67656d6d613437313a6f66663a76313a63393636373732643766386634323863323461373762653936663934653131316261313035326266303933303938663034313362353632633130353964636431",
-      "expected_lane_id": "lane:v1:430444bb58975ab56329c7c3a6c483a1b9cb49d1c089a56f3c93c6aa27d5f9b3"
-    },
-    {
-      "provider_family": "vllm",
-      "instance_id": "helios1",
-      "provider_native_key": "gemma4",
-      "model": "gemma4",
-      "operation": "chat",
-      "framed_hex": {
-        "provider_family": "343a766c6c6d",
-        "instance_id": "373a68656c696f7331",
-        "provider_native_key": "363a67656d6d6134",
-        "operation": "343a63686174",
-        "model": "363a67656d6d6134",
-        "offering_id": "37313a6f66663a76313a66336333316366313830313739363436343163386166656463656261316136366135326661626630313463666632623365316438383165333639376339656334"
-      },
-      "offering_hash_input_hex": "343a766c6c6d373a68656c696f7331363a67656d6d6134",
-      "expected_offering_id": "off:v1:f3c31cf18017964641c8afedceba1a66a52fabf014cff2b3e1d881e3697c9ec4",
-      "lane_hash_input_hex": "6c616e652d763100343a766c6c6d373a68656c696f7331343a63686174363a67656d6d613437313a6f66663a76313a66336333316366313830313739363436343163386166656463656261316136366135326661626630313463666632623365316438383165333639376339656334",
-      "expected_lane_id": "lane:v1:e4a99f7884ea1e9c36b0a0e62da5038832857f0e4b69234133faa81b0e30e880"
-    },
-    {
-      "provider_family": "azure_foundry",
-      "instance_id": "prod:eastus",
-      "provider_native_key": "deploy:gpt-4o",
-      "model": "gpt-4o",
-      "operation": "chat",
-      "framed_hex": {
-        "provider_family": "31333a617a7572655f666f756e647279",
-        "instance_id": "31313a70726f643a656173747573",
-        "provider_native_key": "31333a6465706c6f793a6770742d346f",
-        "operation": "343a63686174",
-        "model": "363a6770742d346f",
-        "offering_id": "37313a6f66663a76313a37646431346639386164346266656335316666623136396561323064633137616564316562653033613363396664666365383966383638343534633035646137"
-      },
-      "offering_hash_input_hex": "31333a617a7572655f666f756e64727931313a70726f643a65617374757331333a6465706c6f793a6770742d346f",
-      "expected_offering_id": "off:v1:7dd14f98ad4bfec51ffb169ea20dc17aed1ebe03a3c9fdfce89f868454c05da7",
-      "lane_hash_input_hex": "6c616e652d76310031333a617a7572655f666f756e64727931313a70726f643a656173747573343a63686174363a6770742d346f37313a6f66663a76313a37646431346639386164346266656335316666623136396561323064633137616564316562653033613363396664666365383966383638343534633035646137",
-      "expected_lane_id": "lane:v1:2334bc87506ae6312a4f64b53798d723d07279294ee6a3181e23db298cf910aa"
-    }
-  ],
-  "tier_invariance": {
-    "note": "The vllm+h200+gemma4+chat vector reproduces identical offering_id/lane_id under every tier; tier is not framed.",
-    "base_vector_index": 0,
-    "tiers": [
-      "local",
-      "frontier"
-    ]
-  },
-  "independence": {
-    "note": "vectors[0] and vectors[1] share provider_family+model but differ by instance_id, proving vllm+h200+gemma4 and vllm+helios1+gemma4 are independent identities.",
-    "vector_indexes": [
-      0,
-      1
-    ]
-  }
-}

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

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Legion::Extensions::Llm::Context do
-  include_context 'with configured Legion::Extensions::Llm'
-  include_context 'with fake llm provider'
-
-  describe '#initialize' do
-    it 'creates a copy of the global configuration' do
-      # Get current config values
-      original_model = Legion::Extensions::Llm.config.default_model
-      original_log_regexp_timeout = Legion::Extensions::Llm.config.log_regexp_timeout
-
-      # Create context with modified config
-      context = Legion::Extensions::Llm.context do |config|
-        config.default_model = 'modified-model'
-        config.fake_llm_api_key = 'modified-key'
-        config.log_regexp_timeout = 5.0
-      end
-
-      # Verify global config is unchanged
-      expect(Legion::Extensions::Llm.config.default_model).to eq(original_model)
-      expect(Legion::Extensions::Llm.config.log_regexp_timeout).to eq(original_log_regexp_timeout)
-
-      # Verify context has modified config
-      expect(context.config.default_model).to eq('modified-model')
-      expect(context.config.fake_llm_api_key).to eq('modified-key')
-      expect(context.config.log_regexp_timeout).to eq(5.0)
-    end
-
-    it 'preserves log_regexp_timeout when Regexp timeout is unavailable' do
-      allow(Regexp).to receive(:respond_to?).and_call_original
-      allow(Regexp).to receive(:respond_to?).with(:timeout).and_return(false)
-      allow(Legion::Extensions::Llm.logger).to receive(:warn)
-
-      context = Legion::Extensions::Llm.context do |config|
-        config.log_regexp_timeout = 5.0
-      end
-
-      expect(context.config.log_regexp_timeout).to eq(5.0)
-    end
-  end
-
-  describe 'context chat operations' do
-    it 'creates a chat with context-specific configuration' do
-      context = Legion::Extensions::Llm.context do |config|
-        config.default_model = 'fake-chat-model'
-      end
-
-      chat = context.chat(provider: :fake_llm, assume_model_exists: true)
-      expect(chat.model.id).to eq('fake-chat-model')
-    end
-
-    it 'allows specifying a model when creating the chat' do
-      context = Legion::Extensions::Llm.context do |config|
-        config.default_model = 'fake-chat-model'
-      end
-
-      chat = context.chat(model: 'other-fake-chat-model', provider: :fake_llm, assume_model_exists: true)
-      expect(chat.model.id).to eq('other-fake-chat-model')
-    end
-  end
-
-  describe 'context embed operations' do
-    it 'respects context-specific embedding model' do
-      context = Legion::Extensions::Llm.context do |config|
-        config.default_embedding_model = 'fake-embed'
-      end
-
-      embedding = context.embed('Test embedding', provider: :fake_llm, assume_model_exists: true)
-      expect(embedding.model).to eq('fake-embed')
-    end
-
-    it 'allows specifying a model at embed time' do
-      context = Legion::Extensions::Llm.context do |config|
-        config.default_embedding_model = 'fake-embed'
-      end
-
-      embedding = context.embed('Test embedding', model: 'override-embed', provider: :fake_llm,
-                                                  assume_model_exists: true)
-      expect(embedding.model).to eq('override-embed')
-    end
-  end
-
-  describe 'multiple independent contexts' do
-    it 'allows multiple contexts with different configurations' do
-      context1 = Legion::Extensions::Llm.context do |config|
-        config.default_model = 'fake-chat-1'
-        config.log_regexp_timeout = 5.0
-      end
-
-      context2 = Legion::Extensions::Llm.context do |config|
-        config.default_model = 'fake-chat-2'
-      end
-
-      chat1 = context1.chat(provider: :fake_llm, assume_model_exists: true)
-      chat2 = context2.chat(provider: :fake_llm, assume_model_exists: true)
-
-      expect(chat1.model.id).to eq('fake-chat-1')
-      expect(context1.config.log_regexp_timeout).to eq(5.0)
-
-      expect(chat2.model.id).to eq('fake-chat-2')
-      expected_timeout = Regexp.respond_to?(:timeout) ? (Regexp.timeout || 1.0) : nil
-      expect(context2.config.log_regexp_timeout).to eq(expected_timeout)
-    end
-
-    it 'ensures changes in one context do not affect another' do
-      context1 = Legion::Extensions::Llm.context do |config|
-        config.fake_llm_api_key = 'key1'
-        config.default_model = 'model1'
-      end
-
-      context2 = Legion::Extensions::Llm.context do |config|
-        config.fake_llm_api_key = 'key2'
-        config.default_model = 'model2'
-      end
-
-      # Modify context1 after creation
-      context1.config.fake_llm_api_key = 'modified-key1'
-
-      # Context2 should be unaffected
-      expect(context2.config.fake_llm_api_key).to eq('key2')
-      expect(context2.config.default_model).to eq('model2')
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Legion::Extensions::Llm::Inventory::Capabilities do
-  describe '.normalize' do
-    it 'returns symbols for raw capability names' do
-      expect(described_class.normalize(%i[tools streaming])).to contain_exactly(:tools, :streaming)
-    end
-
-    it 'collapses provider aliases into the canonical vocabulary' do
-      expect(described_class.normalize([:function_calling])).to include(:tools)
-      expect(described_class.normalize([:tool_use])).to include(:tools)
-      expect(described_class.normalize([:stream])).to include(:streaming)
-    end
-
-    it 'returns an empty array for nil/empty input' do
-      expect(described_class.normalize(nil)).to eq([])
-      expect(described_class.normalize([])).to eq([])
-    end
-
-    it 'is the same vocabulary as Legion::Extensions::Llm::Capabilities' do
-      expect(described_class::ALIASES).to equal(Legion::Extensions::Llm::Capabilities::ALIASES)
-    end
-  end
-
-  describe '.merge' do
-    it 'unions multiple capability sets' do
-      result = described_class.merge([:tools], %i[streaming tools])
-      expect(result).to contain_exactly(:tools, :streaming)
-    end
-  end
-
-  describe '.include_all?' do
-    it 'returns true when required is a subset of available' do
-      expect(described_class.include_all?(%i[tools streaming], [:tools])).to be(true)
-    end
-
-    it 'returns false when required is missing from available' do
-      expect(described_class.include_all?([:streaming], [:tools])).to be(false)
-    end
-  end
-end