llm.rb 12.0.0 → 12.2.0

data/lib/llm/context.rb

@@ -421,6 +421,14 @@ module LLM
       @llm.tracer
     end
 
+    ##
+    # @param [LLM::Tracer, nil] other
+    #  A tracer, or nil.
+    # @return [void]
+    def tracer=(other)
+      @llm.tracer = other || LLM::Tracer::Null.new(@llm)
+    end
+
     ##
     # @return [LLM::Stream, #<<, nil]
     #  Returns a stream object, or nil
@@ -596,7 +604,7 @@ module LLM
     def repair!(messages, prompt)
       message = messages.last
       return unless message&.tool_call?
-      returns = self.returns + [*prompt].grep(LLM::Function::Return)
+      returns = [self.returns, prompt].flatten.grep(LLM::Function::Return)
       cancelled = []
       [*message.extra.tool_calls].each do |tool|
         next if returns.any? { _1.id == tool[:id] }

data/lib/llm/function.rb

@@ -390,6 +390,12 @@ class LLM::Function
         type: "function", name: @name, description: @description,
         parameters: (@params || {type: "object", properties: {}}).to_h.merge(additionalProperties: false), strict: false
       }.compact
+    when "LLM::Mistral"
+      params = @params || {type: "object", properties: {}}
+      {
+        type: "function",
+        function: {name: @name, description: @description, parameters: params}
+      }.compact
     else
       params = @params || {type: "object", properties: {}}
       {

data/lib/llm/json_adapter.rb

@@ -38,11 +38,11 @@ module LLM
     def self.dump(obj, state = nil, **options)
       require "json" unless defined?(::JSON)
       if ::JSON::State === state
-        ::JSON.generate(obj, state)
+        ::JSON.generate(normalize(obj), state)
       elsif state
-        ::JSON.dump(obj, state, **options)
+        ::JSON.dump(normalize(obj), state, **options)
       else
-        ::JSON.dump(obj, **options)
+        ::JSON.dump(normalize(obj), **options)
       end
     end
 
@@ -59,6 +59,32 @@ module LLM
       require "json" unless defined?(::JSON)
       [::JSON::ParserError]
     end
+
+    ##
+    # JSON 3.0 compat
+    # Walks `obj` and encodes every string that is
+    # found into a UTF-8 compatible string.
+    def self.normalize(obj)
+      case obj
+      when String then normalize_string(obj)
+      when Array then obj.map { normalize(_1) }
+      when Hash then obj.map { [_1, normalize(_2)] }.to_h
+      when LLM::Object then obj.map { [_1, normalize(_2)] }.to_h
+      else obj
+      end
+    end
+    private_class_method :normalize
+
+    ##
+    # JSON 3.0 compat
+    # Normalizes a string as a UTF-8 encoded string
+    # that's compatible with the JSON spec.
+    def self.normalize_string(str)
+      return str if str.encoding == Encoding::UTF_8
+      str = (+str).force_encoding("UTF-8")
+      str.valid_encoding? ? str : str.scrub
+    end
+    private_class_method :normalize_string
   end
 
   ##

data/lib/llm/provider.rb

@@ -26,7 +26,7 @@ class LLM::Provider
   #  Requires the net-http-persistent gem.
   # @param [LLM::Transport, Class, nil] transport
   #  Optional override with any {LLM::Transport} instance or subclass.
-  def initialize(key:, host:, port: 443, timeout: 60, ssl: true, base_path: "", persistent: false, transport: nil)
+  def initialize(key:, host:, port: 443, timeout: 180, ssl: true, base_path: "", persistent: false, transport: nil)
     @key = key
     @host = host
     @port = port
@@ -286,7 +286,7 @@ class LLM::Provider
   #  A tracer
   # @return [void]
   def tracer=(tracer)
-    @tracer = tracer
+    @tracer = tracer || LLM::Tracer::Null.new(self)
   end
 
   ##
@@ -303,7 +303,7 @@ class LLM::Provider
   def with_tracer(tracer)
     had_override = weakmap.key?(self)
     previous = weakmap[self]
-    weakmap[self] = tracer
+    weakmap[self] = tracer || LLM::Tracer::Null.new(self)
     yield
   ensure
     if had_override

data/lib/llm/providers/anthropic.rb

@@ -92,10 +92,10 @@ module LLM
 
     ##
     # Returns the default model for chat completions
-    # @see https://docs.anthropic.com/en/docs/about-claude/models/all-models#model-comparison-table claude-sonnet-4-20250514
+    # @see https://docs.anthropic.com/en/docs/about-claude/models/all-models#model-comparison-table claude-opus-4-8
     # @return [String]
     def default_model
-      "claude-sonnet-4-20250514"
+      "claude-opus-4-8"
     end
 
     ##

data/lib/llm/providers/google.rb

@@ -194,9 +194,11 @@ module LLM
     end
 
     def normalize_complete_params(params)
+      except = %i[role model messages stream]
       params = {role: :user, model: default_model}.merge!(params)
       tools  = resolve_tools(params.delete(:tools))
-      params = [params, adapt_generation_config(params), adapt_tools(tools)].inject({}, &:merge!).compact
+      config = adapt_generation_config(params.except(*except))
+      params = [params.except(:schema), config, adapt_tools(tools)].inject({}, &:merge!).compact
       role, model, stream = [:role, :model, :stream].map { params.delete(_1) }
       [params, stream, tools, role, model]
     end

data/lib/llm/providers/llamacpp.rb

@@ -23,7 +23,7 @@ module LLM
     ##
     # @param (see LLM::Provider#initialize)
     # @return [LLM::LlamaCpp]
-    def initialize(host: "localhost", port: 8080, ssl: false, **)
+    def initialize(host: "localhost", port: 8013, ssl: false, **)
       super
     end
 
@@ -71,11 +71,11 @@ module LLM
     end
 
     ##
-    # Returns the default model for chat completions
-    # @see https://ollama.com/library/qwen3 qwen3
-    # @return [String]
+    # Returns nil.
+    # Whatever model is served by llamacpp acts as the default.
+    # @return [nil]
     def default_model
-      "qwen3"
+      nil
     end
   end
 end

data/lib/llm/providers/mistral/request_adapter/completion.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module LLM::Mistral::RequestAdapter
+  ##
+  # @private
+  class Completion
+    ##
+    # @param [LLM::Message, Hash] message
+    #  The message to format
+    def initialize(message)
+      @message = message
+    end
+
+    ##
+    # Adapts the message for the Mistral chat completions API
+    # @return [Hash]
+    def adapt
+      catch(:abort) do
+        if Hash === message
+          {role: message[:role], content: adapt_content(message[:content])}
+        elsif message.tool_call?
+          {role: message.role, content: nil, tool_calls: message.extra[:original_tool_calls]}
+        else
+          adapt_message
+        end
+      end
+    end
+
+    private
+
+    def adapt_message
+      case content
+      when Array
+        adapt_array
+      else
+        {role: message.role, content: adapt_content(content)}
+      end
+    end
+
+    def adapt_array
+      if content.empty?
+        nil
+      elsif returns.any?
+        returns.map do
+          {
+            role: "tool",
+            name: _1.name,
+            tool_call_id: _1.id,
+            content: LLM.json.dump(_1.value)
+          }
+        end
+      else
+        {role: message.role, content: content.flat_map { adapt_content(_1) }}
+      end
+    end
+
+    def adapt_content(content)
+      case content
+      when LLM::Object
+        adapt_object(content)
+      when String
+        [{type: :text, text: content.to_s}]
+      when LLM::Response
+        adapt_remote_file(content)
+      when LLM::Message
+        adapt_content(content.content)
+      when LLM::Function::Return
+        throw(:abort, {
+          role: "tool",
+          name: content.name,
+          tool_call_id: content.id,
+          content: LLM.json.dump(content.value)
+        })
+      else
+        prompt_error!(content)
+      end
+    end
+
+    def adapt_object(object)
+      case object.kind
+      when :image_url
+        [{type: :image_url, image_url: {url: object.value}}]
+      when :local_file
+        adapt_local_file(object.value)
+      when :remote_file
+        adapt_remote_file(object.value)
+      else
+        prompt_error!(object)
+      end
+    end
+
+    def adapt_local_file(file)
+      if file.image?
+        [{type: :image_url, image_url: {url: file.to_data_uri}}]
+      else
+        [{type: :file, file: {filename: file.basename, file_data: file.to_data_uri}}]
+      end
+    end
+
+    def adapt_remote_file(file)
+      if file.file?
+        [{type: :file, file: {file_id: file.id}}]
+      else
+        prompt_error!(file)
+      end
+    end
+
+    def prompt_error!(content)
+      if LLM::Object === content
+        raise LLM::PromptError, "The given LLM::Object with kind '#{content.kind}' is not " \
+                                "supported by the Mistral chat completions API."
+      else
+        raise LLM::PromptError, "The given object (an instance of #{content.class}) " \
+                                "is not supported by the Mistral chat completions API."
+      end
+    end
+
+    def message = @message
+    def content = message.content
+    def returns = content.grep(LLM::Function::Return)
+  end
+end

data/lib/llm/providers/mistral/request_adapter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class LLM::Mistral
+  ##
+  # @private
+  module RequestAdapter
+    require_relative "request_adapter/completion"
+    include LLM::OpenAI::RequestAdapter
+
+    ##
+    # @param [Array<LLM::Message>] messages
+    #  The messages to adapt
+    # @return [Array<Hash>]
+    def adapt(messages, mode: nil)
+      messages.filter_map do |message|
+        Completion.new(message).adapt
+      end
+    end
+  end
+end

data/lib/llm/providers/mistral.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "openai" unless defined?(LLM::OpenAI)
+
+module LLM
+  ##
+  # The Mistral class implements a provider for
+  # [Mistral](https://mistral.ai) through its
+  # OpenAI-compatible API.
+  #
+  # @example
+  #   #!/usr/bin/env ruby
+  #   require "llm"
+  #
+  #   llm = LLM.mistral(key: ENV["KEY"])
+  #   ctx = LLM::Context.new(llm)
+  #   ctx.talk "Hello"
+  #   ctx.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
+  class Mistral < OpenAI
+    require_relative "mistral/request_adapter"
+    include Mistral::RequestAdapter
+
+    HOST = "api.mistral.ai"
+    BASE_PATH = "/v1/"
+
+    ##
+    # @param key (see LLM::Provider#initialize)
+    # @param host (see LLM::Provider#initialize)
+    # @param base_path (see LLM::Provider#initialize)
+    # @return [LLM::Mistral]
+    def initialize(host: HOST, base_path: BASE_PATH, **)
+      super
+    end
+
+    ##
+    # @return [Symbol]
+    #  Returns the provider's name
+    def name
+      :mistral
+    end
+
+    ##
+    # @return [NotImplementedError]
+    def images
+      raise NotImplementedError
+    end
+
+    ##
+    # Provides an embedding.
+    # @param input (see LLM::Provider#embed)
+    # @param model (see LLM::Provider#embed)
+    # @param params (see LLM::Provider#embed)
+    # @raise (see LLM::Provider#request)
+    # @return (see LLM::Provider#embed)
+    def embed(input, model: "mistral-embed", **params)
+      super
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def responses
+      raise NotImplementedError
+    end
+
+    ##
+    # @return [LLM::Mistral::Audio]
+    def audio
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def files
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def moderations
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def vector_stores
+      raise NotImplementedError
+    end
+
+    ##
+    # Returns the default model for chat completions
+    # @return [String]
+    def default_model
+      "mistral-large-latest"
+    end
+  end
+end

data/lib/llm/repl/input.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class LLM::Repl
+  ##
+  # The {LLM::Repl::Input LLM::Repl::Input} class manages
+  # the editable input line shown at the bottom of the REPL.
+  # @api private
+  class Input
+    UP        = Curses::Key::UP
+    DOWN      = Curses::Key::DOWN
+    ENTER     = [Curses::Key::ENTER, 10, 13]
+    BACKSPACE = [Curses::Key::BACKSPACE, 127]
+    EOF       = [nil, 4]
+
+    ##
+    # @param [String, Symbol] provider
+    # @return [LLM::Repl::Input]
+    def initialize(provider)
+      @provider = provider
+      @buffer = +""
+    end
+
+    ##
+    # @param [LLM::Repl::Window] window
+    # @return [String, nil]
+    def readline(window)
+      catch(:done) do
+        @buffer.clear
+        loop do
+          on_char(window, window.getch)
+          window.redraw
+        end
+      end
+    end
+
+    ##
+    # @return [String]
+    def to_s
+      "> #{@buffer}"
+    end
+
+    private
+
+    def on_char(window, char)
+      if EOF.include?(char)
+        throw(:done, nil)
+      elsif BACKSPACE.include?(char)
+        @buffer.chop!
+      elsif ENTER.include?(char)
+        buf = @buffer.dup
+        @buffer.clear
+        throw(:done, buf)
+      elsif char == UP
+        window.scroll_up
+      elsif char == DOWN
+        window.scroll_down
+      elsif String === char
+        @buffer << char
+      else
+        # ???
+      end
+    end
+  end
+end

data/lib/llm/repl/status.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class LLM::Repl
+  ##
+  # The {LLM::Repl::Status LLM::Repl::Status} class stores
+  # the small status line shown at the top of the REPL.
+  # @api private
+  class Status
+    ##
+    # @param [String, Symbol] provider
+    # @return [LLM::Repl::Status]
+    def initialize(provider)
+      @provider = provider
+      @text = "idle"
+    end
+
+    ##
+    # @return [String]
+    attr_reader :provider
+
+    ##
+    # @param [String] value
+    # @return [void]
+    attr_accessor :text
+
+    ##
+    # @return [String]
+    alias_method :to_s, :text
+  end
+end

data/lib/llm/repl/stream.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class LLM::Repl
+  ##
+  # The {LLM::Repl::Stream LLM::Repl::Stream} class manages
+  # the stream for the {LLM::Repl LLM::Repl} class. This class
+  # has defined hooks that receive text, tool calls, and
+  # tool returns.
+  # @api private
+  class Stream < LLM::Stream
+    ##
+    # @param [LLM::Repl] repl
+    # @return [LLM::Repl::Stream]
+    def initialize(repl)
+      @repl = repl
+    end
+
+    ##
+    # @param [String] chars
+    #  One or more chars
+    # @return [void]
+    def on_content(chars)
+      @repl.write(chars)
+    end
+
+    ##
+    # @param [LLM::Function] tool
+    # @param [LLM::Function::Return, nil] error
+    # @return [void]
+    def on_tool_call(tool, error)
+      if error
+        @repl.status = "tool error: #{tool.name}"
+      else
+        @repl.status = "tool: #{tool.name}"
+      end
+    end
+
+    ##
+    # @param [LLM::Function] _tool
+    # @param [LLM::Function::Return] result
+    # @return [void]
+    def on_tool_return(_tool, result)
+      @repl.status = "tool done: #{result.name}"
+    end
+  end
+end

data/lib/llm/repl/transcript.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class LLM::Repl
+  ##
+  # The {LLM::Repl::Transcript LLM::Repl::Transcript} class
+  # stores streamed output for the REPL.
+  # @api private
+  class Transcript
+    WIDTH = 80
+
+    ##
+    # @return [LLM::Repl::Transcript]
+    def initialize
+      @lines = [+""]
+      @offset = 0
+    end
+
+    ##
+    # @param [String] chars
+    # @return [void]
+    def write(chars)
+      chars.each_char { write_char(_1) }
+    end
+
+    ##
+    # @return [void]
+    def scroll_up(height)
+      max = [@lines.size - height, 0].max
+      @offset = [@offset + 1, max].min
+    end
+
+    ##
+    # @return [void]
+    def scroll_down
+      @offset = [@offset - 1, 0].max
+    end
+
+    ##
+    # @param [Integer] height
+    # @return [Array<String>]
+    def visible(height)
+      last = @lines.size - 1 - @offset
+      first = [last - height + 1, 0].max
+      @lines[first..last] || []
+    end
+
+    private
+
+    def write_char(char)
+      if char == "\n"
+        @offset += 1 if @offset > 0
+        @lines << +""
+      elsif char == " " and @lines.last.length >= WIDTH
+        @offset += 1 if @offset > 0
+        @lines << +""
+      else
+        @lines.last << char
+      end
+    end
+  end
+end