llm.rb 4.13.0 → 4.15.0

data/lib/llm/providers/openai/stream_parser.rb

@@ -4,6 +4,8 @@ class LLM::OpenAI
   ##
   # @private
   class StreamParser
+    EMPTY_HASH = {}.freeze
+
     ##
     # Returns the fully constructed response body
     # @return [Hash]
@@ -14,7 +16,11 @@ class LLM::OpenAI
     def initialize(stream)
       @body = {}
       @stream = stream
-      @emits = {tools: []}
+      @emits = {tools: {}}
+      @can_emit_content = stream.respond_to?(:on_content)
+      @can_emit_reasoning_content = stream.respond_to?(:on_reasoning_content)
+      @can_emit_tool_call = stream.respond_to?(:on_tool_call)
+      @can_push_content = stream.respond_to?(:<<)
     end
 
     ##
@@ -45,45 +51,68 @@ class LLM::OpenAI
     end
 
     def merge_choices!(choices)
+      body_choices = @body["choices"]
       choices.each do |choice|
         index = choice["index"]
-        if @body["choices"][index]
-          target_message = @body["choices"][index]["message"]
-          delta = choice["delta"] || {}
-          delta.each do |key, value|
-            next if value.nil?
-            if key == "content"
-              target_message[key] ||= +""
-              target_message[key] << value
-              emit_content(value)
-            elsif key == "reasoning_content"
-              target_message[key] ||= +""
-              target_message[key] << value
-              emit_reasoning_content(value)
-            elsif key == "tool_calls"
-              merge_tools!(target_message, value)
-            else
-              target_message[key] = value
-            end
-          end
+        delta = choice["delta"] || EMPTY_HASH
+        target_message = if body_choice = body_choices[index]
+          body_choice["message"]
+        else
+          body_choices[index] = {"message" => {"role" => "assistant"}}
+          body_choices[index]["message"]
+        end
+        merge_delta!(target_message, delta)
+      end
+    end
+
+    def merge_delta!(target_message, delta)
+      if delta.length == 1
+        merge_single_delta!(target_message, delta)
+      elsif content = delta["content"]
+        if target_content = target_message["content"]
+          target_content << content
+        else
+          target_message["content"] = content
+        end
+        emit_content(content)
+      elsif reasoning = delta["reasoning_content"]
+        if target_reasoning = target_message["reasoning_content"]
+          target_reasoning << reasoning
+        else
+          target_message["reasoning_content"] = reasoning
+        end
+        emit_reasoning_content(reasoning)
+      elsif tool_calls = delta["tool_calls"]
+        merge_tools!(target_message, tool_calls)
+      end
+      return if delta.length <= 1
+      delta.each do |key, value|
+        next if value.nil? || key == "content" || key == "reasoning_content" || key == "tool_calls"
+        target_message[key] = value
+      end
+    end
+
+    def merge_single_delta!(target_message, delta)
+      if content = delta["content"]
+        if target_content = target_message["content"]
+          target_content << content
+        else
+          target_message["content"] = content
+        end
+        emit_content(content)
+        return
+      end
+      if reasoning = delta["reasoning_content"]
+        if target_reasoning = target_message["reasoning_content"]
+          target_reasoning << reasoning
         else
-          message_hash = {"role" => "assistant"}
-          @body["choices"][index] = {"message" => message_hash}
-          (choice["delta"] || {}).each do |key, value|
-            next if value.nil?
-            if key == "content"
-              emit_content(value)
-              message_hash[key] = value
-            elsif key == "reasoning_content"
-              emit_reasoning_content(value)
-              message_hash[key] = value
-            elsif key == "tool_calls"
-              merge_tools!(message_hash, value)
-            else
-              message_hash[key] = value
-            end
-          end
+          target_message["reasoning_content"] = reasoning
         end
+        emit_reasoning_content(reasoning)
+        return
+      end
+      if tool_calls = delta["tool_calls"]
+        merge_tools!(target_message, tool_calls)
       end
     end
 
@@ -93,12 +122,11 @@ class LLM::OpenAI
         tindex = toola["index"]
         tindex = index unless Integer === tindex && tindex >= 0
         toolb = target["tool_calls"][tindex]
-        if toolb && toola["function"] && toolb["function"]
+        functiona = toola["function"]
+        functionb = toolb && toolb["function"]
+        if functiona && functionb
           # Append to existing function arguments
-          toola["function"].each do |func_key, func_value|
-            toolb["function"][func_key] ||= +""
-            toolb["function"][func_key] << func_value
-          end
+          merge_function!(functionb, functiona)
         else
           target["tool_calls"][tindex] = toola
         end
@@ -106,40 +134,61 @@ class LLM::OpenAI
       end
     end
 
+    def merge_function!(target, source)
+      if arguments = source["arguments"]
+        if target_arguments = target["arguments"]
+          target_arguments << arguments
+        else
+          target["arguments"] = arguments
+        end
+      end
+      if name = source["name"]
+        if target_name = target["name"]
+          target_name << name
+        else
+          target["name"] = name
+        end
+      end
+      return if source.length <= 2
+      source.each do |func_key, func_value|
+        next if func_key == "arguments" || func_key == "name"
+        target[func_key] ||= +""
+        target[func_key] << func_value
+      end
+    end
+
     def emit_content(value)
-      if @stream.respond_to?(:on_content)
+      if @can_emit_content
         @stream.on_content(value)
-      elsif @stream.respond_to?(:<<)
+      elsif @can_push_content
         @stream << value
       end
     end
 
     def emit_reasoning_content(value)
-      if @stream.respond_to?(:on_reasoning_content)
+      if @can_emit_reasoning_content
         @stream.on_reasoning_content(value)
       end
     end
 
     def emit_tool(tool, tindex)
-      return unless @stream.respond_to?(:on_tool_call)
-      return unless complete_tool?(tool)
-      return if @emits[:tools].include?(tindex)
-      function, error = resolve_tool(tool)
-      @emits[:tools] << tindex
-      @stream.on_tool_call(function, error)
-    end
-
-    def complete_tool?(tool)
+      return unless @can_emit_tool_call
+      return if @emits[:tools][tindex]
       function = tool["function"]
-      function && tool["id"] && function["name"] && parse_arguments(function["arguments"])
+      return unless function && tool["id"] && function["name"]
+      return unless arguments_complete?(function["arguments"])
+      arguments = parse_arguments(function["arguments"])
+      return unless arguments
+      function, error = resolve_tool(tool, function, arguments)
+      @emits[:tools][tindex] = true
+      @stream.on_tool_call(function, error)
     end
 
-    def resolve_tool(tool)
-      function = tool["function"]
+    def resolve_tool(tool, function, arguments)
       registered = LLM::Function.find_by_name(function["name"])
       fn = (registered || LLM::Function.new(function["name"])).dup.tap do |fn|
         fn.id = tool["id"]
-        fn.arguments = parse_arguments(function["arguments"])
+        fn.arguments = arguments
       end
       [fn, (registered ? nil : @stream.tool_not_found(fn))]
     end
@@ -151,5 +200,10 @@ class LLM::OpenAI
     rescue *LLM.json.parser_error
       nil
     end
+
+    def arguments_complete?(arguments)
+      value = arguments.to_s.rstrip
+      !value.empty? && value.end_with?("}")
+    end
   end
 end

data/lib/llm/response.rb

@@ -2,10 +2,18 @@
 
 module LLM
   ##
-  # {LLM::Response LLM::Response} encapsulates a response
-  # from an LLM provider. It is returned by all methods
-  # that make requests to a provider, and sometimes extended
-  # with provider-specific functionality.
+  # {LLM::Response LLM::Response} is the normalized base shape for
+  # provider and endpoint responses in llm.rb.
+  #
+  # Provider calls return an instance of this class, then extend it
+  # with provider-, endpoint-, or context-specific modules so response
+  # handling can share one common surface without flattening away
+  # specialized behavior.
+  #
+  # The normalized response still keeps the original
+  # {Net::HTTPResponse Net::HTTPResponse} available through {#res}
+  # when callers need direct access to raw HTTP details such as
+  # headers, status codes, or unadapted bodies.
   class Response
     require "json"
 

data/lib/llm/sequel/plugin.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module LLM::Sequel
+  ##
+  # Sequel plugin for persisting {LLM::Context LLM::Context} state.
+  #
+  # This plugin maps model columns onto provider selection, model
+  # selection, usage accounting, and serialized context data while
+  # leaving application-specific concerns such as credentials,
+  # associations, and UI shaping to the host app.
+  #
+  # Context state can be stored as a JSON string (`format: :string`, the
+  # default) or as a structured object (`format: :json` / `:jsonb`) for
+  # databases such as PostgreSQL that can persist JSON natively.
+  # `:json` and `:jsonb` expect a real JSON column type with Sequel handling
+  # JSON typecasting for the model.
+  module Plugin
+    EMPTY_HASH = {}.freeze
+    DEFAULT_USAGE_COLUMNS = {
+      input_tokens: :input_tokens,
+      output_tokens: :output_tokens,
+      total_tokens: :total_tokens
+    }.freeze
+    DEFAULTS = {
+      provider_column: :provider,
+      model_column: :model,
+      data_column: :data,
+      format: :string,
+      usage_columns: DEFAULT_USAGE_COLUMNS,
+      provider: EMPTY_HASH,
+      context: EMPTY_HASH
+    }.freeze
+
+    ##
+    # Called by Sequel when the plugin is first applied to a model class.
+    #
+    # This hook installs the plugin's class- and instance-level behavior on
+    # the target model. It runs before {configure}, so it should only attach
+    # methods and not depend on per-model plugin options.
+    #
+    # @param [Class] model
+    # @return [void]
+    def self.apply(model, **)
+      model.extend ClassMethods
+      model.include InstanceMethods
+    end
+
+    ##
+    # Called by Sequel after {apply} with the options passed to
+    # `plugin :llm, ...`.
+    #
+    # This hook merges plugin defaults with the model's explicit settings and
+    # stores the resolved configuration on the model class for later use by
+    # instance methods such as {InstanceMethods#llm} and {InstanceMethods#ctx}.
+    #
+    # @param [Class] model
+    # @param [Hash] options
+    # @option options [Symbol] :format
+    #   Storage format for the serialized context. Use `:string` for text
+    #   columns, or `:json` / `:jsonb` for structured JSON columns with Sequel
+    #   JSON typecasting enabled.
+    # @return [void]
+    def self.configure(model, options = EMPTY_HASH)
+      options = DEFAULTS.merge(options)
+      usage_columns = DEFAULT_USAGE_COLUMNS.merge(options[:usage_columns] || EMPTY_HASH)
+      model.instance_variable_set(
+        :@llm_plugin_options,
+        options.merge(usage_columns: usage_columns.freeze).freeze
+      )
+    end
+  end
+
+  module Plugin::ClassMethods
+    ##
+    # @return [Hash]
+    def llm_plugin_options
+      @llm_plugin_options || DEFAULTS
+    end
+  end
+
+  module Plugin::InstanceMethods
+    ##
+    # Continues the stored context with new input and flushes it.
+    # @see LLM::Context#talk
+    # @return [LLM::Response]
+    def talk(...)
+      ctx.talk(...).tap { flush }
+    end
+
+    ##
+    # Continues the stored context through the Responses API and flushes it.
+    # @see LLM::Context#respond
+    # @return [LLM::Response]
+    def respond(...)
+      ctx.respond(...).tap { flush }
+    end
+
+    ##
+    # Waits for queued tool work to finish.
+    # @see LLM::Context#wait
+    # @return [Array<LLM::Function::Return>]
+    def wait(...)
+      ctx.wait(...)
+    end
+
+    ##
+    # Calls into the stored context.
+    # @see LLM::Context#call
+    # @return [Object]
+    def call(...)
+      ctx.call(...)
+    end
+
+    ##
+    # @see LLM::Context#messages
+    # @return [Array<LLM::Message>]
+    def messages
+      ctx.messages
+    end
+
+    ##
+    # @note The bang is used because Sequel reserves `model` for the
+    #   underlying model class on instances.
+    # @see LLM::Context#model
+    # @return [String]
+    def model!
+      ctx.model
+    end
+
+    ##
+    # @see LLM::Context#functions
+    # @return [Array<LLM::Function>]
+    def functions
+      ctx.functions
+    end
+
+    ##
+    # @see LLM::Context#cost
+    # @return [LLM::Cost]
+    def cost
+      ctx.cost
+    end
+
+    ##
+    # @see LLM::Context#context_window
+    # @return [Integer]
+    def context_window
+      ctx.context_window
+    rescue LLM::NoSuchModelError, LLM::NoSuchRegistryError
+      0
+    end
+
+    ##
+    # Returns usage from the mapped usage columns.
+    # @return [LLM::Object]
+    def usage
+      LLM::Object.from(
+        input_tokens: self[columns[:input_tokens]] || 0,
+        output_tokens: self[columns[:output_tokens]] || 0,
+        total_tokens: self[columns[:total_tokens]] || 0
+      )
+    end
+
+    private
+
+    ##
+    # Returns the resolved provider instance for this record.
+    # @return [LLM::Provider]
+    def llm
+      options = self.class.llm_plugin_options
+      provider = self[columns[:provider_column]]
+      kwargs = resolve_options(options[:provider])
+      @llm ||= LLM.method(provider).call(**kwargs)
+    end
+
+    ##
+    # @return [LLM::Context]
+    def ctx
+      @ctx ||= begin
+        options = self.class.llm_plugin_options
+        params = resolve_options(options[:context]).dup
+        params[:model] ||= self[columns[:model_column]]
+        ctx = LLM::Context.new(llm, params.compact)
+        data = self[columns[:data_column]]
+        if data.nil? || data == ""
+          ctx
+        else
+          string = case options[:format]
+          when :string then data
+          when :json, :jsonb then LLM.json.dump(data)
+          else raise ArgumentError, "Unknown format: #{options[:format].inspect}"
+          end
+          ctx.restore(string:)
+        end
+      end
+    end
+
+    ##
+    # @return [void]
+    def flush
+      options = self.class.llm_plugin_options
+      update({
+        columns[:data_column] => serialize_context(options[:format]),
+        columns[:input_tokens] => ctx.usage.input_tokens,
+        columns[:output_tokens] => ctx.usage.output_tokens,
+        columns[:total_tokens] => ctx.usage.total_tokens
+      })
+    end
+
+    ##
+    # @return [Hash]
+    def resolve_option(option)
+      case option
+      when Proc then instance_exec(&option)
+      when Hash then option.dup
+      else option
+      end
+    end
+
+    ##
+    # @return [Hash]
+    def resolve_options(option)
+      case option
+      when Proc, Hash then resolve_option(option)
+      else EMPTY_HASH.dup
+      end
+    end
+
+    def serialize_context(format)
+      case format
+      when :string then ctx.to_json
+      when :json, :jsonb then ctx.to_h
+      else raise ArgumentError, "Unknown format: #{format.inspect}"
+      end
+    end
+
+    def columns
+      @columns ||= begin
+        options = self.class.llm_plugin_options
+        usage_columns = options[:usage_columns]
+        {
+          provider_column: options[:provider_column],
+          model_column: options[:model_column],
+          data_column: options[:data_column],
+          input_tokens: usage_columns[:input_tokens],
+          output_tokens: usage_columns[:output_tokens],
+          total_tokens: usage_columns[:total_tokens]
+        }.freeze
+      end
+    end
+  end
+end

data/lib/llm/stream/queue.rb

@@ -54,9 +54,9 @@ class LLM::Stream
     private
 
     def fire_hooks(tasks, results)
-      results.each_with_index do |ret, idx|
+      results.each_with_index do |result, idx|
         tool = tasks[idx]&.function
-        @stream.on_tool_return(tool, ret) if tool
+        @stream.on_tool_return(tool, result) if tool
       end
       results
     end

data/lib/llm/stream.rb

@@ -86,10 +86,10 @@ module LLM
     #   `tool.spawn(:fiber)`, or `tool.spawn(:task)`.
     # @param [LLM::Function] tool
     #  The tool that returned.
-    # @param [LLM::Function::Return] ret
+    # @param [LLM::Function::Return] result
     #  The completed tool return.
     # @return [nil]
-    def on_tool_return(tool, ret)
+    def on_tool_return(tool, result)
       nil
     end
 

data/lib/llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LLM
-  VERSION = "4.13.0"
+  VERSION = "4.15.0"
 end

data/lib/llm.rb

@@ -40,6 +40,14 @@ module LLM
   # Model registry
   @registry = {}
 
+  ##
+  # Shared HTTP clients used by providers.
+  @clients = {}
+
+  ##
+  # @api private
+  def self.clients = @clients
+
   ##
   # @param [Symbol, LLM::Provider] llm
   #  The name of a provider, or an instance of LLM::Provider

data/lib/sequel/plugins/llm.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Sequel
+  module Plugins
+    require "llm/sequel/plugin"
+    Llm = LLM::Sequel::Plugin
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm.rb
 version: !ruby/object:Gem::Version
-  version: 4.13.0
+  version: 4.15.0
 platform: ruby
 authors:
 - Antar Azri
@@ -231,7 +231,6 @@ files:
 - lib/llm/agent.rb
 - lib/llm/bot.rb
 - lib/llm/buffer.rb
-- lib/llm/client.rb
 - lib/llm/context.rb
 - lib/llm/context/deserializer.rb
 - lib/llm/contract.rb
@@ -255,7 +254,9 @@ files:
 - lib/llm/mcp.rb
 - lib/llm/mcp/command.rb
 - lib/llm/mcp/error.rb
+- lib/llm/mcp/mailbox.rb
 - lib/llm/mcp/pipe.rb
+- lib/llm/mcp/router.rb
 - lib/llm/mcp/rpc.rb
 - lib/llm/mcp/transport/http.rb
 - lib/llm/mcp/transport/http/event_handler.rb
@@ -270,6 +271,10 @@ files:
 - lib/llm/object/kernel.rb
 - lib/llm/prompt.rb
 - lib/llm/provider.rb
+- lib/llm/provider/transport/http.rb
+- lib/llm/provider/transport/http/execution.rb
+- lib/llm/provider/transport/http/interruptible.rb
+- lib/llm/provider/transport/http/stream_decoder.rb
 - lib/llm/providers/anthropic.rb
 - lib/llm/providers/anthropic/error_handler.rb
 - lib/llm/providers/anthropic/files.rb
@@ -362,6 +367,7 @@ files:
 - lib/llm/schema/parser.rb
 - lib/llm/schema/string.rb
 - lib/llm/schema/version.rb
+- lib/llm/sequel/plugin.rb
 - lib/llm/server_tool.rb
 - lib/llm/session.rb
 - lib/llm/stream.rb
@@ -376,6 +382,7 @@ files:
 - lib/llm/usage.rb
 - lib/llm/utils.rb
 - lib/llm/version.rb
+- lib/sequel/plugins/llm.rb
 - llm.gemspec
 homepage: https://github.com/llmrb/llm.rb
 licenses:

data/lib/llm/client.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module LLM
-  ##
-  # @api private
-  module Client
-    private
-
-    ##
-    # @api private
-    def persistent_client
-      LLM.lock(:clients) do
-        if clients[client_id]
-          clients[client_id]
-        else
-          require "net/http/persistent" unless defined?(Net::HTTP::Persistent)
-          client = Net::HTTP::Persistent.new(name: self.class.name)
-          client.read_timeout = timeout
-          clients[client_id] = client
-        end
-      end
-    end
-
-    ##
-    # @api private
-    def transient_client
-      client = Net::HTTP.new(host, port)
-      client.read_timeout = timeout
-      client.use_ssl = ssl
-      client
-    end
-
-    def client_id = "#{host}:#{port}:#{timeout}:#{ssl}"
-    def clients = self.class.clients
-  end
-end