ruby_llm-providers-lms 0.1.1 → 0.2.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      # LM Studio serves Anthropic's Messages API alongside the OpenAI and
+      # native surfaces, so RubyLLM's stock Anthropic protocol drives it
+      # unchanged apart from the request path: Protocols::Anthropic posts to
+      # 'v1/messages' against a bare host, while this provider's api_base
+      # already ends in /v1. Streaming follows automatically, because the
+      # protocol's stream_url delegates to completion_url.
+      #
+      # Unlike the real Anthropic API, LM Studio wants no credentials and no
+      # anthropic-version header.
+      #
+      # Model listing and embeddings are not this protocol's business: both
+      # stay on the OpenAI-compatible endpoints LM Studio serves on the same
+      # port, routed there by the provider itself.
+      #
+      #   RubyLLM.configure { |config| config.lms_protocol = :anthropic }
+      class AnthropicMessages < Protocols::Anthropic
+        def completion_url
+          'messages'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Endpoint paths for the LM Studio API integration. LM Studio serves its
+    # native REST API beside the OpenAI-compatible base rather than under it,
+    # so these are spelled relative to an api_base ending in /v1.
+    #
+    # They live on the provider rather than in the modules that use them
+    # because two of those modules are mixed into different objects — Models
+    # into the protocols, ModelManagement into the provider — and a path
+    # spelled twice is a path that can drift.
+    class LMS < Provider
+      NATIVE_V1_MODELS_URL = '../api/v1/models'
+      NATIVE_V0_MODELS_URL = '../api/v0/models'
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      # Model-management methods backed by LM Studio's native REST API
+      # (`/api/v1/models` and friends, reached relative to the OpenAI-compatible
+      # API base). They control what is in memory and on disk on the server:
+      # listing downloaded models with their loaded instances, loading a model
+      # (optionally with a context-length override), unloading an instance,
+      # and downloading a new model.
+      #
+      # Every write here is sent non-idempotent. RubyLLM's Faraday stack
+      # retries a POST that times out or loses its connection, and none of
+      # these are safe to replay: LM Studio answers a second load of a
+      # resident model by starting a second instance, so a slow load that
+      # timed out would end up holding the weights in memory twice.
+      module ModelManagement
+        # Every downloaded model with its native details (architecture,
+        # quantization, capabilities, loaded_instances, ...), as an Array of
+        # Hashes straight from the server.
+        def native_models
+          Array(connection.get(NATIVE_V1_MODELS_URL).body['models'])
+        end
+
+        # The subset of #native_models with at least one loaded instance.
+        def loaded_models
+          native_models.select { |model| Array(model['loaded_instances']).any? }
+        end
+
+        # Loads +model+ into memory. Returns the server's response Hash,
+        # whose 'instance_id' is what #unload_model takes. Extra keyword
+        # options go into the request as-is (the server rejects unknown keys).
+        def load_model(model, context_length: nil, **options)
+          payload = { model: model, context_length: context_length, **options }.compact
+          post_model_action('load', payload)
+        end
+
+        # Unloads the loaded instance named +instance_id+ (from #load_model's
+        # response or a native listing's 'loaded_instances').
+        def unload_model(instance_id)
+          post_model_action('unload', { instance_id: instance_id })
+        end
+
+        # Asks the server to download +model+ (a model key such as
+        # 'qwen/qwen3-4b'). Extra keyword options go into the request as-is.
+        def download_model(model, **)
+          post_model_action('download', { model: model, ** })
+        end
+
+        private
+
+        def post_model_action(action, payload)
+          connection.post("#{NATIVE_V1_MODELS_URL}/#{action}", payload, idempotent: false).body
+        end
+      end
+    end
+  end
+end

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

@@ -5,20 +5,31 @@ module RubyLLM
     class LMS < Provider
       # Model-listing methods for the LM Studio API integration.
       # Enriches the OpenAI-compatible /v1/models listing with details from
-      # LM Studio's native REST API (/api/v0/models): model type, architecture,
-      # quantization, load state, and context length. The native endpoint is
-      # optional — when it is unavailable the plain listing still works.
+      # LM Studio's native REST API: model type, architecture, quantization,
+      # load state, context length, and reasoning controls. Both native
+      # listings are optional — when neither answers the plain listing still
+      # works.
+      #
+      # RubyLLM always lists through the provider's default protocol
+      # (Provider#listing_protocol), so this belongs on :chat_completions
+      # alone — the other protocols reach it through that, whatever
+      # lms_protocol selects.
       module Models
-        NATIVE_MODELS_URL = '../api/v0/models'
+        include NativeV1
+
         CAPABILITY_MAP = {
-          'tool_use' => 'function_calling',
-          'vision' => 'vision'
+          'tool_use' => %w[function_calling tool_choice],
+          'vision' => %w[vision]
         }.freeze
 
         def models_url
           'models'
         end
 
+        # What LM Studio's server provides for every chat model it serves,
+        # whatever the weights were trained for. Structured output is on this
+        # list because the server constrains generation with a grammar built
+        # from the schema, so it holds even for models with no tool training.
         def model_capabilities
           %w[streaming structured_output]
         end
@@ -33,7 +44,7 @@ module RubyLLM
             detail = details[model['id']] || {}
             Model.new(
               id: model['id'],
-              name: model['id'],
+              name: detail['display_name'] || model['id'],
               provider: slug,
               family: detail['arch'] || 'lms',
               created_at: model['created'] ? Time.at(model['created']) : nil,
@@ -58,8 +69,9 @@ module RubyLLM
           return [] if embedding?(detail)
 
           reported = Array(detail['capabilities'])
-          derived = CAPABILITY_MAP.filter_map { |native, capability| capability if reported.include?(native) }
+          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
         end
 
@@ -70,7 +82,17 @@ module RubyLLM
             arch: detail['arch'],
             compatibility_type: detail['compatibility_type'],
             quantization: detail['quantization'],
-            state: detail['state']
+            bits_per_weight: detail['bits_per_weight'],
+            state: detail['state'],
+            display_name: detail['display_name'],
+            description: detail['description'],
+            params_string: detail['params_string'],
+            size_bytes: detail['size_bytes'],
+            variants: detail['variants'],
+            selected_variant: detail['selected_variant'],
+            reasoning_options: detail['reasoning_options'],
+            loaded_context_length: detail['loaded_context_length'],
+            remaining_ttl_seconds: detail['remaining_ttl_seconds']
           }.compact
         end
 
@@ -84,11 +106,21 @@ module RubyLLM
 
         private
 
+        # LM Studio serves two native model listings. v1 is the richer one but
+        # only exists on newer releases; v0 is served by everything that has a
+        # native API at all. Try v1, fall back to v0, then give up quietly.
         def native_model_details
-          Array(@connection.get(NATIVE_MODELS_URL).body['data']).to_h { |detail| [detail['id'], detail] }
+          native_details(NATIVE_V1_MODELS_URL, 'models') { |model| normalize_v1_detail(model) } ||
+            native_details(NATIVE_V0_MODELS_URL, 'data') { |detail| detail } ||
+            {}
+        end
+
+        def native_details(url, key)
+          entries = Array(@connection.get(url).body[key])
+          entries.to_h { |entry| [entry['key'] || entry['id'], yield(entry)] }
         rescue Error, Faraday::Error => e
-          RubyLLM.logger.debug "LM Studio native model details unavailable (#{e.message})."
-          {}
+          RubyLLM.logger.debug "LM Studio native model details unavailable at #{url} (#{e.message})."
+          nil
         end
       end
     end

data/lib/ruby_llm/providers/lms/native_chat/conversation.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      class NativeChat < RubyLLM::Protocol
+        # Maps RubyLLM's role-tagged message history onto the native API's
+        # stateful conversation model: system messages become the
+        # system_prompt, the last assistant response supplies a
+        # previous_response_id to continue from, and only the messages
+        # after it are rendered as input.
+        module Conversation
+          RESPONSE_ID_PATTERN = /"response_id"\s*:\s*"(resp_[0-9a-f]+)"/
+
+          # What an assistant message has to carry for the next turn to
+          # continue from it. It goes on Message#raw_content because that is
+          # the slot RubyLLM persists and rebuilds (see
+          # ActiveRecord::MessageMethods#to_llm) — Message#raw holds a
+          # Faraday::Response that lasts only as long as the request, so a
+          # chat reloaded from the database would have nothing to continue
+          # from. The stock Mistral and Gemini stateful protocols use
+          # raw_content the same way.
+          def conversation_state(data)
+            response_id = data['response_id']
+            { 'response_id' => response_id } if response_id
+          end
+
+          # The `response_id` of the stored server-side response +message+
+          # came from, or nil. Prefers the persisted copy, then the parsed
+          # response body, then raw SSE text.
+          def response_id_from(message)
+            return nil unless message.role == :assistant
+
+            stored_response_id(message.raw_content) || stored_response_id(message.raw&.body)
+          end
+
+          def stored_response_id(source)
+            case source
+            when Hash then source['response_id']
+            when String then source.scan(RESPONSE_ID_PATTERN).flatten.last
+            end
+          end
+
+          def system_prompt_from(messages)
+            prompts = messages.select { |msg| msg.role == :system }.map { |msg| msg.content.to_s }
+            prompts.empty? ? nil : prompts.join("\n\n")
+          end
+
+          # Splits the non-system conversation at the last assistant message
+          # whose response_id is known: that id continues the stored chat and
+          # only the messages after it are sent as input.
+          def split_conversation(conversation)
+            last_continuable = conversation.rindex { |msg| response_id_from(msg) }
+            return [nil, ensure_replayable!(conversation)] unless last_continuable
+
+            [response_id_from(conversation[last_continuable]),
+             ensure_replayable!(conversation[(last_continuable + 1)..])]
+          end
+
+          def ensure_replayable!(messages)
+            return messages unless messages.any? { |msg| msg.role == :assistant }
+
+            raise Error,
+                  "LM Studio's native chat API cannot replay assistant history; it continues " \
+                  'stored conversations by response_id. Keep store enabled (the default) so ' \
+                  'responses carry one, or use the :chat_completions protocol.'
+          end
+
+          def render_input(messages)
+            parts = messages.flat_map { |msg| input_parts(msg) }
+            return parts.first[:content] if parts.length == 1 && parts.first[:type] == 'text'
+
+            parts
+          end
+
+          def input_parts(msg)
+            parts = []
+            content = msg.content.to_s
+            parts << { type: 'text', content: content } unless content.empty?
+            msg.attachments.each { |attachment| parts << input_image_part(attachment) }
+            parts
+          end
+
+          def input_image_part(attachment)
+            raise UnsupportedAttachmentError, attachment.mime_type unless attachment.type == :image
+
+            { type: 'image', data_url: attachment.url? ? attachment.source.to_s : attachment.for_llm }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/lms/native_chat/streaming.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      class NativeChat < RubyLLM::Protocol
+        # Streaming methods for LM Studio's native chat API. The server
+        # sends named SSE events (message.delta, reasoning.delta, chat.end,
+        # plus bookkeeping like prompt_processing.* and model_load.*), each
+        # carrying a JSON object with a matching 'type'.
+        module Streaming
+          # The native stream ends with a `chat.end` event whose `result` is
+          # the same object a non-streamed call returns. Streaming leaves the
+          # Faraday body as raw SSE text, so the result object replaces it —
+          # then `message.raw.body` looks the same either way, response_id
+          # and stats included.
+          def stream_response(payload, additional_headers = {})
+            accumulator = RubyLLM::Protocol::StreamAccumulator.new
+            result = nil
+            response = stream_events(stream_url, payload, additional_headers) do |data|
+              result = data['result'] if data['type'] == 'chat.end' && data['result']
+              chunk = build_chunk(data)
+              accumulator.add chunk
+              yield chunk
+            end
+            response.env[:body] = result if result
+            accumulator.to_message(response)
+          end
+
+          def build_chunk(data)
+            case data['type']
+            when 'message.delta'
+              Chunk.new(role: :assistant, content: data['content'])
+            when 'reasoning.delta'
+              Chunk.new(role: :assistant, content: nil, thinking: Thinking.build(text: data['content']))
+            when 'chat.end'
+              result_chunk(data['result'] || {})
+            else
+              Chunk.new(role: :assistant, content: nil)
+            end
+          end
+
+          def result_chunk(result)
+            stats = result['stats'] || {}
+            Chunk.new(
+              role: :assistant,
+              content: nil,
+              model: result['model_instance_id'],
+              input_tokens: stats['input_tokens'],
+              output_tokens: stats['total_output_tokens'],
+              thinking_tokens: stats['reasoning_output_tokens'],
+              finish_reason: finish_reason_for(stats),
+              raw_content: conversation_state(result)
+            )
+          end
+
+          def parse_streaming_error(data)
+            error = JSON.parse(data)['error']
+            [500, error.is_a?(Hash) ? error['message'] : error.to_s]
+          rescue JSON::ParserError
+            [500, data]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      # Chat protocol for LM Studio's native REST API (`POST /api/v1/chat`).
+      # Select it with `protocol: :native_chat` on the chat or
+      # `config.lms_protocol = :native_chat`.
+      #
+      # The native API is stateful: LM Studio stores each response
+      # server-side and continues a conversation from a `response_id`
+      # rather than replaying role-tagged history. This protocol makes
+      # RubyLLM's ordinary multi-turn Chat work on top of that: each
+      # request sends only the messages newer than the last assistant
+      # response and points `previous_response_id` at it. The id is kept on
+      # `message.raw_content`, which RubyLLM persists, so a conversation
+      # reloaded from the database continues rather than raising. Stats and
+      # server-side tool calls ride on `message.raw.body`.
+      #
+      # Native-only capabilities reach the request through
+      # `with_provider_options`: `integrations:` (MCP plugins or ephemeral
+      # MCP servers the server runs itself), `context_length:`, the sampling
+      # settings the native schema accepts (`top_p`, `top_k`, `min_p`,
+      # `repeat_penalty`), and `store: false` (which trades multi-turn
+      # continuity for privacy).
+      # Client-side RubyLLM tools and structured output are not part of
+      # this wire format — the :chat_completions protocol serves those.
+      class NativeChat < RubyLLM::Protocol
+        include NativeChat::Conversation
+        include NativeChat::Streaming
+
+        def completion_url
+          '../api/v1/chat'
+        end
+
+        def stream_url
+          completion_url
+        end
+
+        # rubocop:disable-next Lint/UnusedMethodArgument
+        def render_payload(messages, tools:, temperature:, model:, stream: false, max_output_tokens: nil,
+                           schema: nil, thinking: nil, citations: false, caching: nil, tool_prefs: nil)
+          ensure_supported!(tools: tools, schema: schema)
+          previous_response_id, pending = split_conversation(messages.reject { |msg| msg.role == :system })
+
+          # Kept for parse_completion_body: the response reports no stop
+          # reason, so the ceiling the request asked for is the only way to
+          # recognize a truncated generation.
+          @max_output_tokens = max_output_tokens
+
+          payload = { model: model.id, input: render_input(pending), stream: stream }
+          system_prompt = system_prompt_from(messages)
+          payload[:system_prompt] = system_prompt if system_prompt
+          payload[:previous_response_id] = previous_response_id if previous_response_id
+          payload[:temperature] = temperature unless temperature.nil?
+          payload[:max_output_tokens] = max_output_tokens unless max_output_tokens.nil?
+          reasoning = resolve_reasoning(thinking)
+          payload[:reasoning] = reasoning if reasoning
+          payload
+        end
+
+        def parse_completion_body(data, raw:)
+          raise Error.new(error_message(data), response: raw) if data['error']
+
+          output = Array(data['output'])
+          raise Error.new('LM Studio returned no output items', response: raw) if output.empty?
+
+          stats = data['stats'] || {}
+          Message.new(
+            role: :assistant,
+            content: output_text(output),
+            thinking: Thinking.build(text: reasoning_text(output)),
+            input_tokens: stats['input_tokens'],
+            output_tokens: stats['total_output_tokens'],
+            thinking_tokens: stats['reasoning_output_tokens'],
+            finish_reason: finish_reason_for(stats),
+            model: data['model_instance_id'],
+            raw_content: conversation_state(data),
+            raw: raw
+          )
+        end
+
+        # Maps RubyLLM thinking options onto the native `reasoning` setting.
+        # The native endpoint's vocabulary is 'off' | 'low' | 'medium' |
+        # 'high' | 'xhigh' | 'on' (models accept a subset), where the
+        # registry — and so the OpenAI endpoint — spells off as 'none'.
+        def resolve_reasoning(thinking)
+          return nil unless thinking
+          return 'off' if thinking.respond_to?(:disabled?) && thinking.disabled?
+
+          effort = thinking.respond_to?(:effort) ? thinking.effort : nil
+          effort ? effort.to_s : 'on'
+        end
+
+        # The native response carries no stop reason, so a generation that
+        # ran into the requested ceiling is only recognizable by its token
+        # count. Without this a truncated answer looked complete.
+        def finish_reason_for(stats)
+          return :stop unless @max_output_tokens
+
+          stats['total_output_tokens'].to_i >= @max_output_tokens ? :length : :stop
+        end
+
+        def ensure_supported!(tools:, schema:)
+          if tools&.any?
+            raise Error,
+                  "LM Studio's native chat API does not run client-side tools; use the " \
+                  ':chat_completions protocol for RubyLLM tools, or have the server run MCP ' \
+                  'tools with with_provider_options(integrations: [...])'
+          end
+          return unless schema
+
+          raise Error,
+                "LM Studio's native chat API does not support structured output; " \
+                'use the :chat_completions protocol for with_schema'
+        end
+
+        def error_message(data)
+          error = data['error']
+          error.is_a?(Hash) ? error['message'] : error.to_s
+        end
+
+        def output_text(output)
+          text = output.filter_map { |item| item['content'] if item['type'] == 'message' }.join
+          text.empty? ? nil : text
+        end
+
+        def reasoning_text(output)
+          output.filter_map { |item| item['content'] if item['type'] == 'reasoning' }.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      # Rewrites entries from LM Studio's native v1 model listing
+      # (GET /api/v1/models) into the vocabulary of the older v0 listing,
+      # which is what LMS::Models reads. v1 states things differently —
+      # capabilities as a Hash of flags rather than an Array of names,
+      # vision as a capability rather than a model type, load state as a
+      # list of running instances — and carries several fields v0 has no
+      # equivalent for.
+      module NativeV1
+        # LM Studio spells its reasoning settings 'off', 'low', 'medium',
+        # 'high', 'xhigh', 'on'. RubyLLM's registry speaks OpenAI's
+        # vocabulary instead: off is an effort named 'none', and a plain
+        # on/off switch is a separate :toggle option rather than an effort.
+        # Translating here is what lets Thinking::Controls — and so
+        # Chat#with_thinking — find any controls at all.
+        REASONING_EFFORT_ALIASES = { 'off' => 'none' }.freeze
+        REASONING_TOGGLE = 'on'
+
+        # Rewrites one v1 entry, keeping the v1-only fields (display name,
+        # parameter count, size on disk, description, variants, reasoning
+        # controls, and the loaded instance's context length and idle TTL)
+        # alongside the v0 ones.
+        def normalize_v1_detail(model)
+          instance = Array(model['loaded_instances']).first
+          capabilities = model['capabilities'] || {}
+          {
+            'type' => normalize_v1_type(model, capabilities),
+            'publisher' => model['publisher'],
+            'arch' => model['architecture'],
+            'compatibility_type' => model['format'],
+            'quantization' => model.dig('quantization', 'name'),
+            'bits_per_weight' => model.dig('quantization', 'bits_per_weight'),
+            'state' => instance ? 'loaded' : 'not-loaded',
+            'max_context_length' => model['max_context_length'],
+            'capabilities' => normalize_v1_capabilities(capabilities),
+            'display_name' => model['display_name'],
+            'params_string' => model['params_string'],
+            'size_bytes' => model['size_bytes'],
+            'description' => model['description'],
+            'variants' => model['variants'],
+            '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')
+          }.compact
+        end
+
+        # v1 reports only 'llm' and 'embedding' and states vision as a
+        # capability; v0 spells those 'embeddings' and 'vlm'.
+        def normalize_v1_type(model, capabilities)
+          return 'embeddings' if model['type'] == 'embedding'
+          return 'vlm' if capabilities['vision']
+
+          model['type']
+        end
+
+        # v1 reports capabilities as a Hash of flags, v0 as an Array of names.
+        def normalize_v1_capabilities(capabilities)
+          names = []
+          names << 'vision' if capabilities['vision']
+          names << 'tool_use' if capabilities['trained_for_tool_use']
+          names
+        end
+
+        # Turns the v1 reasoning block into RubyLLM's reasoning_options: an
+        # :effort option listing the graded settings, and a :toggle when the
+        # model accepts LM Studio's plain 'on'. Returns nil for a model that
+        # reports no reasoning at all, so the key compacts away.
+        def normalize_v1_reasoning(reasoning)
+          allowed = Array(reasoning && reasoning['allowed_options'])
+          return nil if allowed.empty?
+
+          efforts = allowed.reject { |option| option == REASONING_TOGGLE }
+                           .map { |option| REASONING_EFFORT_ALIASES.fetch(option, option) }
+
+          options = []
+          options << reasoning_effort_option(efforts, reasoning['default']) if efforts.any?
+          options << { 'type' => 'toggle' } if allowed.include?(REASONING_TOGGLE)
+          options
+        end
+
+        # The listing's default is only an effort default when it names one:
+        # a model whose default is 'on' is defaulting to its toggle instead.
+        def reasoning_effort_option(efforts, default)
+          default = REASONING_EFFORT_ALIASES.fetch(default, default)
+          option = { 'type' => 'effort', 'values' => efforts }
+          option['default'] = default if efforts.include?(default)
+          option
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class LMS < Provider
+      # LM Studio serves OpenAI's Responses API at POST /v1/responses, and
+      # RubyLLM's stock Responses protocol drives it — except for reasoning,
+      # where the two disagree about where the text lives.
+      #
+      # OpenAI never returns raw reasoning, only an optional summary, so a
+      # reasoning item reads:
+      #
+      #   { type: 'reasoning', summary: [{ type: 'summary_text', text: '...' }] }
+      #
+      # LM Studio runs the model locally and has nothing to hide, so it
+      # returns the reasoning itself, leaving summary empty:
+      #
+      #   { type: 'reasoning', summary: [], content: [{ type: 'reasoning_text', text: '...' }] }
+      #
+      # and streams it as `response.reasoning_text.delta` rather than
+      # `response.reasoning_summary_text.delta`. Reading only OpenAI's shape
+      # loses the reasoning on both paths — the response spends reasoning
+      # tokens and `message.thinking` comes back nil.
+      class Responses < Protocols::Responses
+        REASONING_TEXT_DELTA = 'response.reasoning_text.delta'
+
+        def parse_reasoning_summary(output)
+          super || parse_reasoning_text(output)
+        end
+
+        def parse_reasoning_text(output)
+          texts = output.select { |item| item['type'] == 'reasoning' }.flat_map do |item|
+            Array(item['content']).filter_map { |part| part['text'] if part['type'] == 'reasoning_text' }
+          end
+
+          texts.empty? ? nil : texts.join("\n")
+        end
+
+        def build_chunk(data)
+          return super unless data['type'] == REASONING_TEXT_DELTA
+
+          chunk thinking: Thinking.build(text: data['delta'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # 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.0'
+
+      def self.version
+        VERSION
+      end
+    end
+  end
+end