ruby_llm-providers-lms 0.1.0

data/spec/ruby_llm/chat_schema_spec.rb

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,35 @@
+# 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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,49 @@
+# 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

@@ -0,0 +1,23 @@
+# 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

@@ -0,0 +1,11 @@
+# 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

@@ -0,0 +1,22 @@
+# 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_spec.rb

@@ -0,0 +1,149 @@
+# 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
+
+  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

@@ -0,0 +1,23 @@
+# 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

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,16 @@
+# 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) }
+  config.filter_sensitive_data('<LMS_API_BASE>') { ENV.fetch('LMS_API_BASE', nil) }
+
+  config.before_record do |interaction|
+    next unless interaction.request.headers['Authorization']
+
+    interaction.request.headers['Authorization'] = ['Bearer <AUTH_TOKEN>']
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: ruby_llm-providers-lms
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- madbomber
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0.rc1
+description: Adds LM Studio provider support to RubyLLM via LM Studio's OpenAI-compatible
+  local server, with model listings enriched from LM Studio's native REST API.
+email:
+- dvanhoozer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".flayignore"
+- ".github/workflows/ci.yml"
+- ".github/workflows/gitleaks.yml"
+- ".github/workflows/release.yml"
+- ".overcommit.yml"
+- ".rspec"
+- ".rubocop.yml"
+- Archspec.rb
+- LICENSE
+- README.md
+- lib/ruby_llm/providers/lms.rb
+- lib/ruby_llm/providers/lms/models.rb
+- models.json
+- spec/fixtures/vcr_cassettes/rubyllm_chat_lms_openai_gpt_oss_20b_can_handle_a_multi_turn_conversation.yml
+- spec/fixtures/vcr_cassettes/rubyllm_chat_lms_openai_gpt_oss_20b_can_have_a_basic_conversation.yml
+- spec/fixtures/vcr_cassettes/rubyllm_chat_lms_openai_gpt_oss_20b_can_use_tools.yml
+- spec/fixtures/vcr_cassettes/rubyllm_chat_lms_openai_gpt_oss_20b_returns_the_raw_response.yml
+- spec/fixtures/vcr_cassettes/rubyllm_chat_lms_openai_gpt_oss_20b_supports_streaming_responses.yml
+- spec/fixtures/vcr_cassettes/rubyllm_chat_lms_qwen3_0_6b_bible_assistant_can_have_a_basic_conversation.yml
+- spec/fixtures/vcr_cassettes/rubyllm_chat_lms_qwen3_0_6b_bible_assistant_returns_structured_output.yml
+- spec/fixtures/vcr_cassettes/rubyllm_chat_lms_qwen3_0_6b_bible_assistant_returns_the_raw_response.yml
+- spec/fixtures/vcr_cassettes/rubyllm_embedding_lms_text_embedding_nomic_embed_text_v1_5_embeds_one_text.yml
+- spec/fixtures/vcr_cassettes/rubyllm_embedding_lms_text_embedding_nomic_embed_text_v1_5_embeds_several_texts.yml
+- spec/ruby_llm/chat_schema_spec.rb
+- spec/ruby_llm/chat_spec.rb
+- spec/ruby_llm/chat_streaming_spec.rb
+- spec/ruby_llm/chat_tools_spec.rb
+- spec/ruby_llm/embedding_spec.rb
+- spec/ruby_llm/image_spec.rb
+- spec/ruby_llm/models_spec.rb
+- spec/ruby_llm/moderation_spec.rb
+- spec/ruby_llm/providers/lms_spec.rb
+- spec/ruby_llm/rerank_spec.rb
+- spec/ruby_llm/speech_spec.rb
+- spec/ruby_llm/video_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/rubyllm_configuration.rb
+- spec/support/vcr_configuration.rb
+homepage: https://github.com/madbomber/ruby_llm-providers-lms
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/madbomber/ruby_llm-providers-lms
+  source_code_uri: https://github.com/madbomber/ruby_llm-providers-lms
+  changelog_uri: https://github.com/madbomber/ruby_llm-providers-lms/releases
+  bug_tracker_uri: https://github.com/madbomber/ruby_llm-providers-lms/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: RubyLLM provider for LM Studio.
+test_files: []