ruby_llm-providers-lms 0.1.1 → 0.2.0

data/spec/ruby_llm/chat_schema_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Chat, :live do
-  include_context 'with configured RubyLLM'
-
-  let(:person_schema) do
-    {
-      type: 'object',
-      properties: {
-        name: { type: 'string' },
-        age: { type: 'integer' }
-      },
-      required: %w[name age],
-      additionalProperties: false
-    }
-  end
-
-  each_model(STRUCTURED_OUTPUT_MODELS) do |provider, model|
-    it "#{provider}/#{model} returns structured output" do
-      response = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true)
-                        .with_schema(person_schema)
-                        .ask('Generate a person named John who is 30 years old')
-
-      expect(response.content).to be_a(String)
-      expect(response.parsed).to include('name' => 'John', 'age' => 30)
-    end
-  end
-end

data/spec/ruby_llm/chat_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Chat, :live do
-  include_context 'with configured RubyLLM'
-
-  each_model(CHAT_MODELS) do |provider, model|
-    it "#{provider}/#{model} can have a basic conversation" do
-      response = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true).ask("What's 2 + 2?")
-
-      expect(response.content).to include('4')
-      expect(response.role).to eq(:assistant)
-      expect(response.tokens.input.to_i).to be_positive
-      expect(response.tokens.output.to_i).to be_positive
-    end
-
-    it "#{provider}/#{model} returns the raw response" do
-      response = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true)
-                        .ask('What is the capital of France?')
-
-      expect(response.raw.status).to eq(200)
-      expect(response.raw.headers).not_to be_empty
-      expect(response.raw.body).not_to be_empty
-      expect(response.raw.env.request_body).not_to be_empty
-    end
-
-    it "#{provider}/#{model} can handle a multi-turn conversation" do
-      chat = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true)
-
-      expect(chat.ask('Who created the programming language Ruby?').content).to match(/Matz|Matsumoto/i)
-      expect(chat.ask('What year was Ruby first released?').content).to include('199')
-    end
-  end
-end

data/spec/ruby_llm/chat_streaming_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Chat, :live do
-  include_context 'with configured RubyLLM'
-
-  each_model(CHAT_MODELS) do |provider, model|
-    it "#{provider}/#{model} supports streaming responses" do
-      chunks = []
-      chat = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true)
-
-      response = chat.ask('Count from 1 to 3') { |chunk| chunks << chunk }
-
-      expect(chunks).not_to be_empty
-      expect(chunks.first).to be_a(RubyLLM::Chunk)
-      expect(response.raw.status).to eq(200)
-      expect(response.raw.headers).not_to be_empty
-      expect(response.raw.env.request_body).not_to be_empty
-    end
-  end
-end

data/spec/ruby_llm/chat_tools_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Chat, :live do
-  include_context 'with configured RubyLLM'
-
-  let(:weather_tool) do
-    Class.new(RubyLLM::Tool) do
-      description 'Gets current weather for a location'
-      parameter :latitude, description: 'Latitude'
-      parameter :longitude, description: 'Longitude'
-
-      def execute(latitude:, longitude:)
-        "Current weather at #{latitude}, #{longitude}: 15°C, Wind: 10 km/h"
-      end
-    end
-  end
-
-  each_model(TOOL_MODELS) do |provider, model|
-    it "#{provider}/#{model} can use tools" do
-      chat = RubyLLM.chat(model: model, provider: provider, assume_model_exists: true).with_tools(weather_tool)
-      response = chat.ask("What's the weather in Berlin? Use 52.5200, 13.4050.")
-
-      expect(response.content).to include('15')
-      expect(response.content).to include('10')
-      expect(chat.messages.any?(&:tool_call?)).to be(true)
-    end
-  end
-end

data/spec/ruby_llm/embedding_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Embedding, :live do
-  include_context 'with configured RubyLLM'
-
-  each_model(EMBEDDING_MODELS) do |provider, model, model_info|
-    it "#{provider}/#{model} embeds one text" do
-      embedding = RubyLLM.embed(
-        "Ruby is a programmer's best friend",
-        model: model,
-        provider: provider,
-        assume_model_exists: true
-      )
-
-      expect(embedding.vectors).to be_an(Array)
-      expect(embedding.vectors.first).to be_a(Numeric)
-      expect(embedding.model).to eq(model)
-      expect(embedding.tokens.input.to_i).to be >= 0
-    end
-
-    it "#{provider}/#{model} embeds several texts" do
-      embeddings = RubyLLM.embed(
-        %w[Ruby Python JavaScript],
-        model: model,
-        provider: provider,
-        assume_model_exists: true
-      )
-
-      expect(embeddings.vectors.size).to eq(3)
-      expect(embeddings.vectors).to all(be_an(Array))
-    end
-
-    next unless model_info[:dimensions]
-
-    it "#{provider}/#{model} supports custom dimensions" do
-      embedding = RubyLLM.embed(
-        'Ruby',
-        model: model,
-        provider: provider,
-        assume_model_exists: true,
-        dimensions: model_info[:dimensions]
-      )
-
-      expect(embedding.vectors.length).to eq(model_info[:dimensions])
-    end
-  end
-end

data/spec/ruby_llm/image_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Image, :live do
-  include_context 'with configured RubyLLM'
-
-  each_model(IMAGE_GENERATION_MODELS) do |provider, model, model_info|
-    it "#{provider}/#{model} paints an image" do
-      image = RubyLLM.paint(
-        'a siamese cat',
-        model: model,
-        provider: provider,
-        assume_model_exists: true,
-        provider_options: model_info.fetch(:provider_options, {})
-      )
-
-      expect(image.mime_type).to include('image')
-      expect(image.model).to eq(model)
-      expect(image.to_blob.bytesize).to be > 1000
-    end
-  end
-end

data/spec/ruby_llm/models_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Models do
-  include_context 'with configured RubyLLM'
-
-  it 'expects generated providers to add registry metadata before use' do
-    expect(RubyLLM::Providers::LMS.assume_models_exist?).to be(false)
-  end
-end

data/spec/ruby_llm/moderation_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Moderation, :live do
-  include_context 'with configured RubyLLM'
-
-  each_model(MODERATION_MODELS) do |provider, model|
-    it "#{provider}/#{model} moderates content" do
-      moderation = RubyLLM.moderate(
-        'This is a safe message',
-        model: model,
-        provider: provider,
-        assume_model_exists: true
-      )
-
-      expect(moderation).to be_a(described_class)
-      expect(moderation.results).to all(be_a(RubyLLM::Moderation::Result))
-      expect(moderation.flagged?).to be_in([true, false])
-    end
-  end
-end

data/spec/ruby_llm/providers/lms/connection_guard_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Providers::LMS::ConnectionGuard do
-  subject(:guard) { described_class.new(connection) }
-
-  let(:provider) { instance_double(RubyLLM::Providers::LMS, api_base: 'http://localhost:1234/v1') }
-  let(:connection) { instance_double(RubyLLM::Transport::Connection, provider: provider) }
-
-  { get: ['models'], post: ['chat/completions', {}], patch: ['models', {}], delete: ['models'] }.each do |verb, args|
-    it "wraps a connection failure on ##{verb} in a RubyLLM::Error" do
-      allow(connection).to receive(verb).and_raise(Faraday::ConnectionFailed, 'Connection refused')
-
-      expect { guard.public_send(verb, *args) }.to raise_error(RubyLLM::Error) do |error|
-        expect(error.message).to include('http://localhost:1234/v1')
-        expect(error.message).to include('lms server start')
-        expect(error.cause).to be_a(Faraday::ConnectionFailed)
-      end
-    end
-  end
-
-  it 'passes successful calls through with arguments and block' do
-    response = instance_double(Faraday::Response)
-    request = Object.new
-    allow(connection).to receive(:post).with('chat/completions', { model: 'x' }, usage: nil)
-                                       .and_yield(request).and_return(response)
-
-    yielded = nil
-    result = guard.post('chat/completions', { model: 'x' }, usage: nil) { |req| yielded = req }
-
-    expect(result).to be(response)
-    expect(yielded).to be(request)
-  end
-
-  it 'lets other errors propagate untouched' do
-    allow(connection).to receive(:get).and_raise(RubyLLM::UnauthorizedError.new('nope'))
-
-    expect { guard.get('models') }.to raise_error(RubyLLM::UnauthorizedError, 'nope')
-  end
-
-  it 'names the server address and the start command in its message' do
-    expect(guard.unreachable_message)
-      .to eq('Cannot connect to the LM Studio server at http://localhost:1234/v1. ' \
-             'Start it with `lms server start`.')
-  end
-end

data/spec/ruby_llm/providers/lms_spec.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Providers::LMS do
-  subject(:provider) { described_class.new(config) }
-
-  let(:config) do
-    RubyLLM::Configuration.new.tap do |provider_config|
-      provider_config.lms_api_base = 'http://example.test:1234/v1'
-    end
-  end
-
-  it 'is registered with RubyLLM' do
-    expect(RubyLLM::Provider.resolve(:lms)).to eq(described_class)
-  end
-
-  it 'registers its protocols' do
-    expect(described_class.protocols).to include(
-      chat_completions: described_class::ChatCompletions,
-      responses: RubyLLM::Protocols::Responses
-    )
-  end
-
-  it 'declares provider configuration' do
-    expect(described_class.configuration_options).to eq(%i[lms_api_base lms_api_key])
-    expect(described_class.configuration_requirements).to eq([])
-  end
-
-  it 'is a local provider with a human-readable name' do
-    expect(described_class.local?).to be(true)
-    expect(described_class.display_name).to eq('LM Studio')
-  end
-
-  it 'uses the configured API base' do
-    expect(provider.api_base).to eq('http://example.test:1234/v1')
-  end
-
-  it 'defaults to the LM Studio server address' do
-    provider = described_class.new(RubyLLM::Configuration.new)
-    expect(provider.api_base).to eq('http://localhost:1234/v1')
-  end
-
-  it 'sends no Authorization header without an API key' do
-    expect(provider.headers).to eq({})
-  end
-
-  it 'sends a bearer token when an API key is configured' do
-    config.lms_api_key = 'test-key'
-    expect(provider.headers).to eq('Authorization' => 'Bearer test-key')
-  end
-
-  it 'guards its connection against a server that is not running' do
-    expect(provider.connection).to be_a(described_class::ConnectionGuard)
-  end
-
-  describe 'model listing' do
-    subject(:protocol) do
-      described_class::ChatCompletions.new(described_class.new(config))
-    end
-
-    let(:llm_detail) do
-      {
-        'type' => 'llm',
-        'arch' => 'qwen2',
-        'publisher' => 'lmstudio-community',
-        'compatibility_type' => 'gguf',
-        'quantization' => 'Q4_K_M',
-        'state' => 'loaded',
-        'max_context_length' => 32_768,
-        'capabilities' => ['tool_use']
-      }
-    end
-    let(:vlm_detail) { { 'type' => 'vlm', 'arch' => 'qwen2_vl' } }
-    let(:embedding_detail) { { 'type' => 'embeddings', 'arch' => 'nomic-bert' } }
-
-    describe '#build_modalities' do
-      it 'maps chat models to text in and out' do
-        expect(protocol.build_modalities(llm_detail)).to eq(input: %w[text], output: %w[text])
-      end
-
-      it 'adds image input for vision models' do
-        expect(protocol.build_modalities(vlm_detail)).to eq(input: %w[text image], output: %w[text])
-      end
-
-      it 'maps embedding models to embedding output' do
-        expect(protocol.build_modalities(embedding_detail)).to eq(input: %w[text], output: %w[embeddings])
-      end
-    end
-
-    describe '#build_capabilities' do
-      it 'derives function calling from reported tool_use' do
-        expect(protocol.build_capabilities(llm_detail))
-          .to eq(%w[streaming structured_output function_calling])
-      end
-
-      it 'derives vision from the model type' do
-        expect(protocol.build_capabilities(vlm_detail)).to include('vision')
-      end
-
-      it 'reports no chat capabilities for embedding models' do
-        expect(protocol.build_capabilities(embedding_detail)).to eq([])
-      end
-
-      it 'falls back to base capabilities without native details' do
-        expect(protocol.build_capabilities({})).to eq(%w[streaming structured_output])
-      end
-    end
-
-    describe '#build_metadata' do
-      it 'keeps native details and drops missing fields' do
-        metadata = protocol.build_metadata({ 'owned_by' => 'organization_owner' }, llm_detail)
-        expect(metadata).to eq(
-          owned_by: 'organization_owner',
-          publisher: 'lmstudio-community',
-          arch: 'qwen2',
-          compatibility_type: 'gguf',
-          quantization: 'Q4_K_M',
-          state: 'loaded'
-        )
-      end
-
-      it 'compacts unknown details away' do
-        expect(protocol.build_metadata({ 'owned_by' => 'organization_owner' }, {}))
-          .to eq(owned_by: 'organization_owner')
-      end
-    end
-
-    describe '#parse_list_models_response' do
-      it 'builds enriched models from the listing and native details' do
-        response = instance_double(Faraday::Response,
-                                   body: { 'data' => [{ 'id' => 'qwen2.5-7b-instruct',
-                                                        'owned_by' => 'organization_owner' }] })
-        models = protocol.parse_list_models_response(response, 'lms',
-                                                     details: { 'qwen2.5-7b-instruct' => llm_detail })
-        expect(models.length).to eq(1)
-        model = models.first
-        expect(model.id).to eq('qwen2.5-7b-instruct')
-        expect(model.provider).to eq('lms')
-        expect(model.family).to eq('qwen2')
-        expect(model.context_window).to eq(32_768)
-        expect(model.capabilities).to include('function_calling')
-      end
-
-      it 'builds plain models when native details are unavailable' do
-        response = instance_double(Faraday::Response, body: { 'data' => [{ 'id' => 'some-model' }] })
-        model = protocol.parse_list_models_response(response, 'lms').first
-        expect(model.family).to eq('lms')
-        expect(model.capabilities).to eq(%w[streaming structured_output])
-      end
-    end
-  end
-end

data/spec/ruby_llm/rerank_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Rerank, :live do
-  include_context 'with configured RubyLLM'
-
-  each_model(RERANK_MODELS) do |provider, model|
-    it "#{provider}/#{model} orders documents by relevance" do
-      rerank = RubyLLM.rerank(
-        'What is the capital of the United States?',
-        ['Carson City is the capital of Nevada.', 'Washington, D.C. is the capital of the United States.'],
-        model: model,
-        provider: provider,
-        assume_model_exists: true
-      )
-
-      expect(rerank.results.first.document).to include('Washington')
-      expect(rerank.results.first.score).to be > rerank.results.last.score
-      expect(rerank.results.map(&:index)).to contain_exactly(0, 1)
-    end
-  end
-end

data/spec/ruby_llm/speech_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Speech, :live do
-  include_context 'with configured RubyLLM'
-
-  each_model(SPEECH_MODELS) do |provider, model, model_info|
-    it "#{provider}/#{model} speaks" do
-      speech = RubyLLM.speak(
-        'Ruby is a programming language designed for developer happiness.',
-        model: model,
-        provider: provider,
-        assume_model_exists: true,
-        voice: model_info[:voice],
-        format: model_info[:format]
-      )
-
-      expect(speech.data).to be_a(String)
-      expect(speech.data.bytesize).to be > 1000
-      expect(speech.model).to eq(model)
-      expect(speech.mime_type).to start_with('audio/')
-    end
-  end
-end

data/spec/ruby_llm/video_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe RubyLLM::Video, :live do
-  include_context 'with configured RubyLLM'
-
-  before do
-    RubyLLM.config.video_generation_poll_interval = VCR.current_cassette&.recording? ? 5 : 0
-  end
-
-  each_model(VIDEO_GENERATION_MODELS) do |provider, model, model_info|
-    it "#{provider}/#{model} animates a video" do
-      video = RubyLLM.animate(
-        'a calm ocean wave at sunset',
-        model: model,
-        provider: provider,
-        assume_model_exists: true,
-        provider_options: model_info.fetch(:provider_options, {})
-      )
-
-      expect(video.mime_type).to include('video')
-      expect(video.url || video.data).not_to be_nil
-      expect(video.to_blob.bytesize).to be > 10_000
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'dotenv/load'
-require 'fileutils'
-
-require 'vcr'
-require 'ruby_llm/providers/lms'
-require 'webmock/rspec'
-
-Dir[File.expand_path('support/**/*.rb', __dir__)].each { |file| require file }
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-  config.expect_with(:rspec) { |expectations| expectations.syntax = :expect }
-  config.order = :random
-  Kernel.srand config.seed
-
-  config.around(:each, :live) do |example|
-    cassette_name = example.full_description.downcase.gsub(/[^a-z0-9]+/, '_').delete_prefix('_').delete_suffix('_')
-    cassette_path = File.join(VCR.configuration.cassette_library_dir, "#{cassette_name}.yml")
-
-    VCR.use_cassette(cassette_name) { example.run }
-    FileUtils.rm_f(cassette_path) if example.exception
-  end
-end

data/spec/support/models.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-# Model matrices for the live contract specs. LM Studio serves whatever
-# models are downloaded on this machine, so these ids are machine-specific;
-# swap in ids from `lms ls` (or models.json) when recording cassettes.
-# See RubyLLM's full live matrix and specs: https://github.com/crmne/ruby_llm/tree/main/spec
-PROVIDER = :lms
-CHAT_MODELS = [
-  { provider: PROVIDER, model: 'openai/gpt-oss-20b' }
-].freeze
-TOOL_MODELS = CHAT_MODELS
-# gpt-oss models mangle json_schema values on LM Studio (harmony format);
-# qwen3 models honor it.
-STRUCTURED_OUTPUT_MODELS = [
-  { provider: PROVIDER, model: 'qwen3-0.6b-bible-assistant' }
-].freeze
-
-EMBEDDING_MODELS = [
-  { provider: PROVIDER, model: 'text-embedding-nomic-embed-text-v1.5' }
-].freeze
-IMAGE_GENERATION_MODELS = [].freeze
-SPEECH_MODELS = [].freeze
-VIDEO_GENERATION_MODELS = [].freeze
-MODERATION_MODELS = [].freeze
-RERANK_MODELS = [].freeze
-
-def each_model(models)
-  models.each { |model_info| yield model_info[:provider], model_info[:model], model_info }
-end

data/spec/support/rubyllm_configuration.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_context 'with configured RubyLLM' do
-  before do
-    RubyLLM.configure do |config|
-      config.lms_api_key = ENV.fetch('LMS_API_KEY', 'test')
-      config.lms_api_base = ENV.fetch('LMS_API_BASE', 'http://localhost:1234/v1')
-      config.max_retries = 0
-      config.retry_backoff_factor = 0
-      config.retry_interval = 0
-      config.retry_interval_randomness = 0
-    end
-  end
-end

data/spec/support/vcr_configuration.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-VCR.configure do |config|
-  config.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
-  config.hook_into :webmock
-  config.default_cassette_options = { record: ENV['CI'] ? :none : :once }
-  config.allow_http_connections_when_no_cassette = true
-  config.filter_sensitive_data('<LMS_API_KEY>') { ENV.fetch('LMS_API_KEY', nil) }
-
-  # Normalize the recorder's server address to the default so cassettes
-  # replay on any machine (CI included) without LMS_API_BASE set. The
-  # placeholder must be a parseable URI, not a <TOKEN>: VCR parses every
-  # cassette URI on replay and raises URI::InvalidURIError otherwise.
-  config.filter_sensitive_data(RubyLLM::Providers::LMS::DEFAULT_API_BASE) do
-    base = ENV.fetch('LMS_API_BASE', nil)
-    base unless base.nil? || base == RubyLLM::Providers::LMS::DEFAULT_API_BASE
-  end
-
-  config.before_record do |interaction|
-    next unless interaction.request.headers['Authorization']
-
-    interaction.request.headers['Authorization'] = ['Bearer <AUTH_TOKEN>']
-  end
-end