ruby_llm-providers-lms 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f9e03ee21a139367f15f9e32795a4a204a7304f9ea9b13df18e44aa69f6db6e
-  data.tar.gz: '016568a32db5f3be0a6fd5dee88c827ff618a2a2dac9f1e6d6117c143a94acd7'
+  metadata.gz: ddec10e0078375411b8c6edfa0b2a476665402b3ee58bd58cf1038efa8e647bd
+  data.tar.gz: 7aacef68d4b0e03034647931f3106d65f4aa611059fb2bce1000d61740280a79
 SHA512:
-  metadata.gz: c7f09535ee1ceb6032d2fad666dac9e7d9ae11ac544d1f1289e812005deb2103df46f9af5fb589023c6a4a4286c5001b2285b77b138e1ccbba04243a3dab67c1
-  data.tar.gz: 2c5160290b2f84aeca8a125c4f8f0866a0cf2da1e93a9078ac6aacb675e82026b52ff3ef5bea09632ff61ac99578fe164df2df0ac86f85cd542494ec79a81968
+  metadata.gz: 6e90e96b77af748c918eaf933311d0990b013bfbeef8aad9d145b4f62f7a374826d8799420051f58a189b10db5ab03105a14ea88d40d2d0d677115b6fea85f5d
+  data.tar.gz: 57d08ddeaf9b6b9f23449bd4351648eafaa36c5d57323df138a11a1b6be3d17a5547528d7286252b414e18ea5340dfe76f915a0606b0212e1fb3356f9e27b0a5

data/CHANGELOG.md

@@ -5,6 +5,45 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- Judgments with LM Studio decision models (LM Studio 0.4.26 and later), through
+  RubyLLM 2.1's `RubyLLM::Judge` and `RubyLLM.judge`. Two new protocols:
+  - `:decisions`: OpenAI's Decisions API at `POST /v1/decisions`, and the default.
+    Accepts images through `with:`, sent as inline base64 data URLs. Answers are
+    matched to questions by name, since RubyLLM 2.1.1 pairs them by position.
+    If the response names no model, the requested model id is used.
+  - `:system_one`: the Jev (TypeSafe) System One API at `POST /v1/systemone`.
+    Accepts images, sent as inline base64 data URLs in the top-level `images`
+    array where LM Studio reads them (the stock protocol refuses images). An
+    image judged without text sends an empty `state`, which the endpoint
+    requires.
+- Live specs and cassettes for judgments with Kev 0.8B, D1 Omni 600M and Clef
+  Flash, over both endpoints, including image input.
+- Examples 16-20, on open-source decision models: the three question types, a
+  reusable `RubyLLM::Judge` subclass, a sweep of every decision model over both
+  endpoints, image judgments, and a decision model screening an inbox ahead of
+  a chat model. `examples/common.rb` gains `DECISION_MODEL`
+  (`LMS_DECISION_MODEL`, default `d1-omni-600m`) and `judgment_context`.
+- A documentation site (MkDocs Material, `docs/` and `mkdocs.yml`) published
+  to GitHub Pages: getting started, the chat protocols, judgments and decision
+  models (with measured results per model and endpoint), models and model
+  management, architecture, API reference, examples and development notes.
+- `lms_judgment_protocol` configuration option to choose between the two
+  endpoints (`:decisions` by default). Judgments go to a decision endpoint
+  whatever `lms_protocol` selects.
+- Decision models (`type: "decision"` in `GET /api/v1/models`) are listed as
+  judgment models: output modality and capability `judgment`, image input when
+  LM Studio reports a vision adapter, and `decision_type` in the metadata.
+
+### Changed
+
+- Require `ruby_llm >= 2.1.1`, the first release line with judgments.
+- Specs follow RubyLLM 2.1, which releases a request's body once the response
+  arrives (`raw.env.request_body` is now `nil`).
+
 ## [0.2.1] - 2026-09-18
 
 ### Changed

data/README.md

@@ -44,6 +44,10 @@ Messages API, and LM Studio's own **native REST** API — which adds inference
 stats, server-stored conversations, and model management. The provider works
 out of the box: no API key, no configuration.
 
+**Documentation:** <https://madbomber.github.io/ruby_llm-providers-lms> —
+guides for every protocol, judgments with open-source decision models, model
+management, and the examples.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -95,6 +99,7 @@ provider.list_models.each { |model| puts model.id }
 | [OpenAI](#the-openai-api) | `POST /v1/chat/completions`, `POST /v1/responses`, `GET /v1/models`, `POST /v1/embeddings`, `POST /v1/completions` | `:chat_completions` (default), `:responses` |
 | [Anthropic](#the-anthropic-api) | `POST /v1/messages` | `:anthropic` |
 | [Native REST](#the-native-rest-api) | v0: `POST /api/v0/chat/completions`, `GET /api/v0/models`, `POST /api/v0/embeddings`, … <br> v1: `POST /api/v1/chat`, `GET /api/v1/models`, `POST /api/v1/models/load`, `/unload`, `/download` | `:native_v0`, `:native_chat` |
+| [Decisions](#judgments-with-decision-models) | OpenAI: `POST /v1/decisions` <br> Jev System One: `POST /v1/systemone` | `:decisions` (default for judgments), `:system_one` |
 
 Everything but the default is opt-in. Pick a protocol process-wide, for one
 conversation, or for a single chat:
@@ -121,10 +126,11 @@ Stay on the default unless you need something only another column offers.
 | Inference stats | no | no | no | yes, via `raw` | yes, via `tokens` |
 | LM Studio request extras | yes | yes | yes | yes | sampling only — see below |
 | Server-stored conversations | no | no | no | no | yes |
-| Reasoning control | yes | yes | **no** | yes | yes |
-| Reasoning text returned | yes | yes | no | yes | yes |
+| Reasoning control | yes | yes | yes | yes | yes |
+| Reasoning text returned | yes | yes | yes | yes | yes |
 
-Checked against LM Studio 0.4.24+1 (see [Tested against](#tested-against)).
+Checked against LM Studio 0.4.24+1, the `:anthropic` reasoning rows against
+0.4.26 (see [Tested against](#tested-against)).
 Where a protocol ignores something silently rather than raising, the section
 below says so — those are the cases that cost you an afternoon.
 
@@ -196,10 +202,10 @@ Model 'bible-study-phi3-mini' does not expose reasoning configuration.
 ```
 
 So on `:native_chat`, only ask for reasoning from a model whose listing
-reports it. `with_thinking` and `with_thinking(false)` already refuse
-client-side for a model in the registry that reports none; an explicit
-`with_thinking(effort:)`, or a model id not in your catalog, reaches the
-server and gets the error above.
+reports it. `with_thinking` and `with_thinking(false)` refuse before any
+request is sent (on `ask`) for a model that reports no reasoning options —
+one in the registry without them, or one not in your catalog at all. Only an
+explicit `with_thinking(effort:)` reaches the server and gets the error above.
 
 Which efforts you can ask for depends on what you have downloaded:
 
@@ -298,6 +304,10 @@ Plain exchanges, streaming (proper `message_start` / `content_block_delta`
 SSE events) and tool calls (`tool_use` blocks with `stop_reason: "tool_use"`,
 executed as ordinary `RubyLLM::Tool` objects in your process) all work; the
 live specs in `spec/ruby_llm/chat_anthropic_spec.rb` cover all three.
+Reasoning works too: `with_thinking(effort: :low)` sends Anthropic's
+`thinking` field, and the reasoning comes back as a `thinking` content block
+in `response.thinking.text` (no thinking token count, since Anthropic's usage
+block has none).
 
 **`with_schema` does not work here, and fails quietly.** LM Studio ignores the
 schema and nothing raises. The same model and schema, two protocols:
@@ -384,7 +394,9 @@ response = chat.ask('Hello')
   filtering. Executed tool calls appear in `response.raw.body['output']`.
 - **Per-request context length** — `with_provider_options(context_length: 8192)`.
 - **Opting out of storage** — `with_provider_options(store: false)` keeps the
-  conversation off the server, at the cost of multi-turn continuity.
+  conversation off the server. The chat is then single-turn: a second `ask`
+  raises, because the endpoint cannot replay history and has nothing stored
+  to continue from.
 
 - **Sampling settings** — `top_p`, `top_k`, `min_p` and `repeat_penalty` are
   part of the native request schema, so `with_provider_options(top_k: 40)` and
@@ -431,6 +443,100 @@ API — set idle TTL per request through the OpenAI endpoints (see
 
 ---
 
+# Judgments with decision models
+
+LM Studio 0.4.26 added two endpoints for **decision models**: models that
+answer typed questions with probabilities instead of generating text.
+RubyLLM 2.1 calls these **judgments** (`RubyLLM::Judge`, `RubyLLM.judge`),
+and this gem points them at LM Studio. One call can ask three kinds of
+question:
+
+| Question | Answer |
+| --- | --- |
+| `probability` | the chance a condition holds, 0 to 1 |
+| `choice` | one option from a fixed set, a probability for every option, and a confidence |
+| `score` | a position on an ordered scale (it can fall between levels), per-level probabilities, and a confidence |
+
+```ruby
+class TicketTriage < RubyLLM::Judge
+  model 'clef-flash', provider: :lms
+
+  probability :urgent, 'Does this need attention today?'
+
+  choice :department, 'Which team should handle this?' do
+    billing   'Payments and refunds'
+    technical 'Bugs and integrations'
+    other     'Everything else'
+  end
+
+  score :frustration, 'How frustrated is the customer?', %w[Calm Frustrated Angry]
+end
+
+judgment = TicketTriage.judge('I was charged twice. Please fix it today.')
+judgment.urgent.probability     # => 0.96
+judgment.department.choice      # => :billing
+judgment.department.confidence  # => 0.87
+judgment.frustration.score      # => 1.68
+```
+
+Those numbers came from Clef Flash. Smaller models are faster but less sure:
+on the same ticket, D1 Omni 600M also picks `:billing` (confidence 0.78), while
+Kev 0.8B picks `:other`.
+
+RubyLLM's [judgments guide](https://rubyllm.com/judgments/) covers the full
+DSL: structured input, dynamic options, and thresholds.
+
+**You need a decision model.** A chat model is rejected outright — *"Invalid
+model identifier"*, or *"There are no downloaded decision models"* when you
+have none at all. A decision model has to be one LM Studio
+itself identifies as such. A model sharing a decision model's name is not
+enough: an MLX conversion of Clef Flash loads as an ordinary LLM and is
+rejected by both endpoints. `GET /api/v1/models` reports the ones LM Studio
+recognizes with `type: "decision"`, and `provider.list_models` lists them as
+judgment models (output modality `judgment`, capability `judgment`, plus
+`decision_type` in the metadata).
+
+These GGUF decision models are known to work (download with `lms get <URL>`):
+
+| Model | Hugging Face | Size | Images |
+| --- | --- | --- | --- |
+| Kev 0.8B | [ggml-org/Kev-0.8B-GGUF](https://huggingface.co/ggml-org/Kev-0.8B-GGUF) | 0.8 GB | no |
+| D1 Omni 600M | [LiquidAI/d1-omni-600M-GGUF](https://huggingface.co/LiquidAI/d1-omni-600M-GGUF) | 0.8 GB | yes |
+| Clef Flash | [ggml-org/Clef-Flash-GGUF](https://huggingface.co/ggml-org/Clef-Flash-GGUF) | 7.4 GB | yes |
+
+Other repositories tagged
+[`decision-model`](https://huggingface.co/models?other=decision-model) on
+Hugging Face should work too, as long as LM Studio lists them as decision
+models.
+
+## Choosing the endpoint
+
+Judgments go to a decision endpoint whatever `lms_protocol` says; a chat
+protocol never handles them. `lms_judgment_protocol` picks which one:
+
+| | `:decisions` (default) | `:system_one` |
+| --- | --- | --- |
+| Endpoint | `POST /v1/decisions` (OpenAI's Decisions API) | `POST /v1/systemone` (Jev / TypeSafe System One) |
+| Images (`with:`) | inline base64 data URLs in the input content | inline base64 data URLs in a top-level `images` array |
+
+```ruby
+RubyLLM.configure { |config| config.lms_judgment_protocol = :system_one }
+```
+
+Both endpoints answer the same questions with the same models, and both take
+images for a model with a vision adapter (`list_models` shows `image` among its
+input modalities):
+
+```ruby
+TicketTriage.judge('Customer photo of the delivered box', with: 'box.png')
+```
+
+Each answer reports the instance that served it as `judgment.model`. When LM
+Studio loads a model on demand beside a copy you loaded yourself, that is the
+instance's identifier (`clef-flash:2`), not the model id.
+
+---
+
 # Models on your machine
 
 ## What listing enrichment adds
@@ -454,6 +560,7 @@ up whatever the server knows:
 | `reasoning_options` | v1 | `[{type: "effort", values: ["none", "low", "medium", "xhigh"], default: "xhigh"}, {type: "toggle"}]` |
 | `loaded_context_length` | v1 | `8192` (the loaded instance's window, which can be smaller than `context_window`) |
 | `remaining_ttl_seconds` | v1 | `1050` — how long before an idle JIT-loaded instance evicts |
+| `decision_type` | v1, decision models only | the kind of decision model, when LM Studio reports one |
 
 `Model#capabilities` picks up `function_calling` and `tool_choice` from the
 model's tool-use training, `vision` from its vision flag, and `reasoning` from
@@ -463,6 +570,10 @@ from your schema, so structured output works even on weights with no tool
 training (whether the *values* are any good is a separate question — see the
 gpt-oss caveat in `spec/support/models.rb`).
 
+Decision models are the exception: they don't chat, so they get the
+`judgment` capability and output modality and nothing else. They take image
+input only when LM Studio reports a vision adapter for them.
+
 ## The packaged catalog (models.json)
 
 The gem ships a `models.json` at its root. **This file is only a sample**,
@@ -525,8 +636,9 @@ models are resident right now.
 | Component | Version |
 | --- | --- |
 | LM Studio (macOS) | 0.4.24+1 |
+| LM Studio (macOS), judgments and `:anthropic` reasoning | 0.4.26 |
 | `lms` CLI | commit `ff50809` |
-| RubyLLM | 2.0.0 |
+| RubyLLM | 2.1.1 (cassettes recorded on 2.0.0) |
 
 This is the server the committed VCR cassettes were recorded from, and the
 version every endpoint and capability claim above was checked against. LM
@@ -571,7 +683,9 @@ the ones that need a particular kind of model are commented there:
 | `REASONING_OFF_MODELS` | one of those that also reports LM Studio's `off` |
 | `VISION_MODELS` | a model flagged `vision: true` |
 | `EMBEDDING_MODELS` | an embedding model |
-| `NATIVE_CHAT_MODELS`, `NATIVE_REASONING_MODELS`, `MANAGEMENT_MODEL` | small models, so load/unload cycles stay fast |
+| `NATIVE_CHAT_MODELS`, `MANAGEMENT_MODEL` | small models, so load/unload cycles stay fast |
+| `NATIVE_REASONING_MODELS` | a model that emits reasoning items on the native endpoint (gpt-oss does; most instruct fine-tunes do not) |
+| `JUDGMENT_MODELS` | decision models LM Studio tags `type: "decision"`; `vision: true` for ones with a vision adapter |
 
 The portable contract specs are adapted from
 [RubyLLM's live specs](https://github.com/crmne/ruby_llm/tree/main/spec/ruby_llm).

data/lib/ruby_llm/providers/lms/decisions.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      # LM Studio serves OpenAI's Decisions API at POST /v1/decisions for
+      # decision models (LM Studio 0.4.26 and later), and RubyLLM's stock
+      # Decisions protocol drives it — RubyLLM::Judge and RubyLLM.judge
+      # reach it through LMS#judge. Questions go out as an Array and the
+      # answers come back as one, each echoing its question's name.
+      #
+      # RubyLLM 2.1.1 pairs answers with questions by position, which holds
+      # only while the server answers in the order it was asked. This reads
+      # them by name instead (as RubyLLM's main branch now does), and takes
+      # the model id from the request when the response omits it.
+      class Decisions < Protocols::OpenAI::Decisions
+        def parse_judgment_response(response, questions:)
+          body = response.body
+          named = body.fetch('answers').to_h { |answer| [answer.fetch('name'), answer] }
+          answers = questions.values.to_h do |question|
+            [question.name, parse_answer(named.fetch(question.name.to_s), question)]
+          end
+          RubyLLM::Judgment.new(answers:, model: body['model'] || judged_model_id, raw: response,
+                                model_info: @model, tokens: parse_tokens(body['usage']))
+        rescue KeyError, NoMethodError, TypeError => e
+          raise Error.new("LM Studio Decisions returned an invalid judgment: #{e.message}", response:)
+        end
+
+        def judged_model_id
+          @model.respond_to?(:id) ? @model.id : @model
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/lms/models.rb

@@ -57,22 +57,31 @@ module RubyLLM
           end
         end
 
+        # A decision model answers judgments (RubyLLM.judge), not chat, and
+        # reads images only when LM Studio reports a vision adapter for it.
         def build_modalities(detail)
           return { input: %w[text], output: %w[embeddings] } if embedding?(detail)
 
           input = %w[text]
           input << 'image' if vision?(detail)
-          { input: input, output: %w[text] }
+          { input: input, output: decision?(detail) ? %w[judgment] : %w[text] }
         end
 
         def build_capabilities(detail)
           return [] if embedding?(detail)
+          return %w[judgment] if decision?(detail)
 
+          model_capabilities + chat_capabilities(detail)
+        end
+
+        # The capabilities a chat model's own weights bring, beyond what the
+        # server provides for every chat model (model_capabilities).
+        def chat_capabilities(detail)
           reported = Array(detail['capabilities'])
           derived = CAPABILITY_MAP.filter_map { |native, names| names if reported.include?(native) }.flatten
           derived << 'vision' if vision?(detail) && !derived.include?('vision')
           derived << 'reasoning' if detail['reasoning_options']
-          model_capabilities + derived
+          derived
         end
 
         def build_metadata(model, detail)
@@ -92,7 +101,8 @@ module RubyLLM
             selected_variant: detail['selected_variant'],
             reasoning_options: detail['reasoning_options'],
             loaded_context_length: detail['loaded_context_length'],
-            remaining_ttl_seconds: detail['remaining_ttl_seconds']
+            remaining_ttl_seconds: detail['remaining_ttl_seconds'],
+            decision_type: detail['decision_type']
           }.compact
         end
 
@@ -100,7 +110,13 @@ module RubyLLM
           detail['type'] == 'embeddings'
         end
 
+        def decision?(detail)
+          detail['type'] == 'decision'
+        end
+
         def vision?(detail)
+          return detail['has_vision_adapter'] == true if decision?(detail)
+
           detail['type'] == 'vlm' || Array(detail['capabilities']).include?('vision')
         end
 

data/lib/ruby_llm/providers/lms/native_v1.rb

@@ -45,14 +45,19 @@ module RubyLLM
             'selected_variant' => model['selected_variant'],
             'reasoning_options' => normalize_v1_reasoning(capabilities['reasoning']),
             'loaded_context_length' => instance&.dig('config', 'context_length'),
-            'remaining_ttl_seconds' => instance&.dig('remaining_ttl_seconds')
+            'remaining_ttl_seconds' => instance&.dig('remaining_ttl_seconds'),
+            'decision_type' => model['decision_type'],
+            'has_vision_adapter' => model['has_vision_adapter']
           }.compact
         end
 
-        # v1 reports only 'llm' and 'embedding' and states vision as a
-        # capability; v0 spells those 'embeddings' and 'vlm'.
+        # v1 reports 'llm', 'embedding', and 'decision', and states vision as
+        # a capability; v0 spells the first two 'embeddings' and 'vlm'. A
+        # decision model stays 'decision' even when it reads images — that
+        # is what has_vision_adapter says.
         def normalize_v1_type(model, capabilities)
           return 'embeddings' if model['type'] == 'embedding'
+          return 'decision' if model['type'] == 'decision'
           return 'vlm' if capabilities['vision']
 
           model['type']

data/lib/ruby_llm/providers/lms/system_one.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      # LM Studio also serves the Jev (TypeSafe) System One API at
+      # POST /v1/systemone for decision models. Questions go out as a Hash
+      # keyed by name and the answers come back keyed the same way, so the
+      # stock protocol needs only two changes:
+      #
+      # - The path. It spells it 'v1/systemone' for TypeSafe's bare host,
+      #   which beside an api_base ending in /v1 would land on
+      #   /v1/v1/systemone.
+      # - Images. The stock protocol refuses them; LM Studio reads them from a
+      #   top-level `images` array of inline base64 data URLs. (A
+      #   Responses-style content array in `state` is accepted but its images
+      #   are ignored -- the answer doesn't change with the picture.) `state`
+      #   is required even then, so an image judged without text sends an
+      #   empty one.
+      #
+      # Select it over Decisions with `config.lms_judgment_protocol =
+      # :system_one`.
+      class SystemOne < Protocols::SystemOne
+        def judgment_url
+          'systemone'
+        end
+
+        def render_judgment_payload(input, with: [], **)
+          payload = super(input, with: [], **)
+          return payload if with.empty?
+
+          payload.merge(state: payload[:state] || '', images: render_images(with))
+        end
+
+        def render_images(attachments)
+          attachments.map do |attachment|
+            raise UnsupportedAttachmentError, attachment.mime_type unless attachment.image?
+
+            attachment.for_llm
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/lms/version.rb

@@ -5,7 +5,7 @@ module RubyLLM
     # Version of the ruby_llm-providers-lms gem. Kept in its own file so the
     # gemspec can read the literal without loading the provider.
     class LMS < Provider
-      VERSION = '0.2.1'
+      VERSION = '0.3.0'
 
       def self.version
         VERSION

data/lib/ruby_llm/providers/lms.rb

@@ -8,6 +8,8 @@ require 'ruby_llm/providers/lms/native_v1'
 require 'ruby_llm/providers/lms/models'
 require 'ruby_llm/providers/lms/responses'
 require 'ruby_llm/providers/lms/anthropic_messages'
+require 'ruby_llm/providers/lms/decisions'
+require 'ruby_llm/providers/lms/system_one'
 require 'ruby_llm/providers/lms/model_management'
 require 'ruby_llm/providers/lms/native_chat/conversation'
 require 'ruby_llm/providers/lms/native_chat/streaming'
@@ -49,6 +51,10 @@ module RubyLLM
       protocol :native_chat, NativeChat
       protocol :native_v0, NativeChatCompletions
       protocol :anthropic, AnthropicMessages
+      protocol :decisions, Decisions
+      protocol :system_one, SystemOne
+
+      DEFAULT_JUDGMENT_PROTOCOL = :decisions
 
       include ModelManagement
 
@@ -80,13 +86,20 @@ module RubyLLM
         embedding_protocol(model).render_embedding(text, model: model_id_for(model), dimensions: dimensions)
       end
 
+      # Which of LM Studio's two decision endpoints RubyLLM.judge talks to:
+      # :decisions (POST /v1/decisions) unless lms_judgment_protocol says
+      # :system_one (POST /v1/systemone).
+      def judgment_protocol
+        @config.lms_judgment_protocol || DEFAULT_JUDGMENT_PROTOCOL
+      end
+
       class << self
         def display_name
           'LM Studio'
         end
 
         def configuration_options
-          %i[lms_api_base lms_api_key]
+          %i[lms_api_base lms_api_key lms_judgment_protocol]
         end
 
         def configuration_requirements
@@ -100,6 +113,14 @@ module RubyLLM
 
       private
 
+      # Judgments go to a decision endpoint whichever chat dialect is in
+      # effect: lms_protocol would otherwise route RubyLLM.judge to, say,
+      # the Anthropic protocol, which has no judgments at all.
+      def resolve_protocol(name, model, operation: nil, **)
+        name ||= judgment_protocol if operation == :judge
+        super
+      end
+
       def embedding_protocol(model)
         protocols.fetch(:chat_completions).new(self, model)
       end

metadata

@@ -1,76 +1,81 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-providers-lms
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
-- madbomber
+  - 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
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.0.0
-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.
+  - !ruby/object:Gem::Dependency
+    name: ruby_llm
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: 2.1.1
+    type: :runtime
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: 2.1.1
+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
+  - dvanhoozer@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
-- LICENSE
-- README.md
-- lib/ruby_llm/providers/lms.rb
-- lib/ruby_llm/providers/lms/anthropic_messages.rb
-- lib/ruby_llm/providers/lms/connection_guard.rb
-- lib/ruby_llm/providers/lms/endpoints.rb
-- lib/ruby_llm/providers/lms/model_management.rb
-- lib/ruby_llm/providers/lms/models.rb
-- lib/ruby_llm/providers/lms/native_chat.rb
-- lib/ruby_llm/providers/lms/native_chat/conversation.rb
-- lib/ruby_llm/providers/lms/native_chat/streaming.rb
-- lib/ruby_llm/providers/lms/native_v1.rb
-- lib/ruby_llm/providers/lms/responses.rb
-- lib/ruby_llm/providers/lms/version.rb
-- models.json
-homepage: https://github.com/madbomber/ruby_llm-providers-lms
+  - CHANGELOG.md
+  - LICENSE
+  - README.md
+  - lib/ruby_llm/providers/lms.rb
+  - lib/ruby_llm/providers/lms/anthropic_messages.rb
+  - lib/ruby_llm/providers/lms/connection_guard.rb
+  - lib/ruby_llm/providers/lms/decisions.rb
+  - lib/ruby_llm/providers/lms/endpoints.rb
+  - lib/ruby_llm/providers/lms/model_management.rb
+  - lib/ruby_llm/providers/lms/models.rb
+  - lib/ruby_llm/providers/lms/native_chat.rb
+  - lib/ruby_llm/providers/lms/native_chat/conversation.rb
+  - lib/ruby_llm/providers/lms/native_chat/streaming.rb
+  - lib/ruby_llm/providers/lms/native_v1.rb
+  - lib/ruby_llm/providers/lms/responses.rb
+  - lib/ruby_llm/providers/lms/system_one.rb
+  - lib/ruby_llm/providers/lms/version.rb
+  - models.json
+homepage: "https://github.com/madbomber/ruby_llm-providers-lms"
 licenses:
-- MIT
+  - 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/blob/main/CHANGELOG.md
-  bug_tracker_uri: https://github.com/madbomber/ruby_llm-providers-lms/issues
-  rubygems_mfa_required: 'true'
+  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/blob/main/CHANGELOG.md"
+  bug_tracker_uri: "https://github.com/madbomber/ruby_llm-providers-lms/issues"
+  rubygems_mfa_required: "true"
 rdoc_options: []
 require_paths:
-- lib
+  - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      version: '3.3'
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: "3.3"
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.1.0.beta2
 specification_version: 4
 summary: RubyLLM provider for LM Studio.
 test_files: []