llm.rb 8.0.0 → 9.0.0

data/lib/llm.rb

@@ -14,8 +14,8 @@ module LLM
   require_relative "llm/object"
   require_relative "llm/model"
   require_relative "llm/version"
-  require_relative "llm/utils"
   require_relative "llm/message"
+  require_relative "llm/transport"
   require_relative "llm/response"
   require_relative "llm/mime"
   require_relative "llm/multipart"
@@ -37,22 +37,12 @@ module LLM
 
   ##
   # Thread-safe monitors for different contexts
-  @monitors = {require: Monitor.new, clients: Monitor.new, inherited: Monitor.new, registry: Monitor.new, mcp: Monitor.new}
+  @monitors = {require: Monitor.new, inherited: Monitor.new, registry: Monitor.new, mcp: Monitor.new}
 
   ##
   # Model registry
   @registry = {}
 
-  ##
-  # Shared HTTP clients used by providers.
-  @clients = {}
-
-  ##
-  # @api private
-  def self.clients
-    @clients
-  end
-
   ##
   # Requires an optional runtime dependency
   # @raise [LLM::DependencyError]
@@ -161,6 +151,14 @@ module LLM
     LLM::OpenAI.new(**)
   end
 
+  ##
+  # @param (see LLM::Bedrock#initialize)
+  # @return (see LLM::Bedrock#initialize)
+  def bedrock(**)
+    lock(:require) { require_relative "llm/providers/bedrock" unless defined?(LLM::Bedrock) }
+    LLM::Bedrock.new(**)
+  end
+
   ##
   # @param key (see LLM::XAI#initialize)
   # @param host (see LLM::XAI#initialize)

data/llm.gemspec

@@ -8,22 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["Antar Azri", "0x1eef", "Christos Maris", "Rodrigo Serrano"]
   spec.email = ["azantar@proton.me", "0x1eef@hardenedbsd.org"]
 
-  spec.summary = "Lightweight runtime for building capable AI systems in Ruby."
-
-  spec.description = <<~DESCRIPTION
-  llm.rb is a lightweight runtime for building capable AI systems in Ruby.
-  It is not just an API wrapper. llm.rb gives you one runtime for providers,
-  contexts, agents, tools, MCP servers, streaming, schemas, files, and
-  persisted state, so real systems can be built out of one coherent
-  execution model instead of a pile of adapters. It stays close to Ruby, runs
-  on the standard library by default, loads optional pieces only when needed,
-  includes built-in ActiveRecord support through acts_as_llm and
-  acts_as_agent, includes built-in Sequel support through plugin :llm,
-  and is designed for engineers who want control over long-lived,
-  tool-capable, stateful AI workflows instead of just request/response
-  helpers.
-  DESCRIPTION
-
+  spec.summary = "Ruby's most capable AI runtime"
+  spec.description = spec.summary
   spec.license = "0BSD"
   spec.required_ruby_version = ">= 3.3.0"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm.rb
 version: !ruby/object:Gem::Version
-  version: 8.0.0
+  version: 9.0.0
 platform: ruby
 authors:
 - Antar Azri
@@ -264,18 +264,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
-description: |
-  llm.rb is a lightweight runtime for building capable AI systems in Ruby.
-  It is not just an API wrapper. llm.rb gives you one runtime for providers,
-  contexts, agents, tools, MCP servers, streaming, schemas, files, and
-  persisted state, so real systems can be built out of one coherent
-  execution model instead of a pile of adapters. It stays close to Ruby, runs
-  on the standard library by default, loads optional pieces only when needed,
-  includes built-in ActiveRecord support through acts_as_llm and
-  acts_as_agent, includes built-in Sequel support through plugin :llm,
-  and is designed for engineers who want control over long-lived,
-  tool-capable, stateful AI workflows instead of just request/response
-  helpers.
+description: Ruby's most capable AI runtime
 email:
 - azantar@proton.me
 - 0x1eef@hardenedbsd.org
@@ -287,6 +276,7 @@ files:
 - LICENSE
 - README.md
 - data/anthropic.json
+- data/bedrock.json
 - data/deepseek.json
 - data/google.json
 - data/openai.json
@@ -314,6 +304,7 @@ files:
 - lib/llm/file.rb
 - lib/llm/function.rb
 - lib/llm/function/array.rb
+- lib/llm/function/call_group.rb
 - lib/llm/function/fiber_group.rb
 - lib/llm/function/fork.rb
 - lib/llm/function/fork/job.rb
@@ -351,10 +342,6 @@ files:
 - lib/llm/pipe.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
@@ -369,6 +356,17 @@ files:
 - lib/llm/providers/anthropic/response_adapter/web_search.rb
 - lib/llm/providers/anthropic/stream_parser.rb
 - lib/llm/providers/anthropic/utils.rb
+- lib/llm/providers/bedrock.rb
+- lib/llm/providers/bedrock/error_handler.rb
+- lib/llm/providers/bedrock/models.rb
+- lib/llm/providers/bedrock/request_adapter.rb
+- lib/llm/providers/bedrock/request_adapter/completion.rb
+- lib/llm/providers/bedrock/response_adapter.rb
+- lib/llm/providers/bedrock/response_adapter/completion.rb
+- lib/llm/providers/bedrock/response_adapter/models.rb
+- lib/llm/providers/bedrock/signature.rb
+- lib/llm/providers/bedrock/stream_decoder.rb
+- lib/llm/providers/bedrock/stream_parser.rb
 - lib/llm/providers/deepseek.rb
 - lib/llm/providers/deepseek/request_adapter.rb
 - lib/llm/providers/deepseek/request_adapter/completion.rb
@@ -461,8 +459,14 @@ files:
 - lib/llm/tracer/logger.rb
 - lib/llm/tracer/null.rb
 - lib/llm/tracer/telemetry.rb
+- lib/llm/transport.rb
+- lib/llm/transport/execution.rb
+- lib/llm/transport/http.rb
+- lib/llm/transport/persistent_http.rb
+- lib/llm/transport/response.rb
+- lib/llm/transport/response/http.rb
+- lib/llm/transport/stream_decoder.rb
 - lib/llm/usage.rb
-- lib/llm/utils.rb
 - lib/llm/version.rb
 - lib/sequel/plugins/agent.rb
 - lib/sequel/plugins/llm.rb
@@ -491,5 +495,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.3
 specification_version: 4
-summary: Lightweight runtime for building capable AI systems in Ruby.
+summary: Ruby's most capable AI runtime
 test_files: []

data/lib/llm/provider/transport/http/execution.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module LLM::Provider::Transport
-  class HTTP
-    ##
-    # Internal HTTP request execution methods for {LLM::Provider}.
-    #
-    # This module handles provider-side HTTP execution, response parsing,
-    # streaming, and request body setup through
-    # {LLM::Provider::Transport::HTTP}.
-    #
-    # @api private
-    module HTTP::Execution
-      private
-
-      ##
-      # Executes a HTTP request
-      # @param [Net::HTTPRequest] request
-      #  The request to send
-      # @param [Proc] b
-      #  A block to yield the response to (optional)
-      # @return [Net::HTTPResponse]
-      #  The response from the server
-      # @raise [LLM::Error::Unauthorized]
-      #  When authentication fails
-      # @raise [LLM::Error::RateLimit]
-      #  When the rate limit is exceeded
-      # @raise [LLM::Error]
-      #  When any other unsuccessful status code is returned
-      # @raise [SystemCallError]
-      #  When there is a network error at the operating system level
-      # @return [Net::HTTPResponse]
-      def execute(request:, operation:, stream: nil, stream_parser: self.stream_parser, model: nil, inputs: nil, &b)
-        owner = transport.request_owner
-        tracer = self.tracer
-        span = tracer.on_request_start(operation:, model:, inputs:)
-        res = transport.request(request, owner:) do |http|
-          perform_request(http, request, stream, stream_parser, &b)
-        end
-        [handle_response(res, tracer, span), span, tracer]
-      rescue *transport.interrupt_errors
-        raise LLM::Interrupt, "request interrupted" if transport.interrupted?(owner)
-        raise
-      end
-
-      ##
-      # Handles the response from a request
-      # @param [Net::HTTPResponse] res
-      #  The response to handle
-      # @param [Object, nil] span
-      #  The span
-      # @return [Net::HTTPResponse]
-      def handle_response(res, tracer, span)
-        case res
-        when Net::HTTPOK then res.body = parse_response(res)
-        else error_handler.new(tracer, span, res).raise_error!
-        end
-        res
-      end
-
-      ##
-      # Parse a HTTP response
-      # @param [Net::HTTPResponse] res
-      # @return [LLM::Object, String]
-      def parse_response(res)
-        case res["content-type"]
-        when %r{\Aapplication/json\s*} then LLM::Object.from(LLM.json.load(res.body))
-        else res.body
-        end
-      end
-
-      ##
-      # @param [Net::HTTPRequest] req
-      #  The request to set the body stream for
-      # @param [IO] io
-      #  The IO object to set as the body stream
-      # @return [void]
-      def set_body_stream(req, io)
-        req.body_stream = io
-        req["transfer-encoding"] = "chunked" unless req["content-length"]
-      end
-
-      ##
-      # Performs the request on the given HTTP connection.
-      # @param [Net::HTTP] http
-      # @param [Net::HTTPRequest] request
-      # @param [Object, nil] stream
-      # @param [Class] stream_parser
-      # @param [Proc, nil] b
-      # @return [Net::HTTPResponse]
-      def perform_request(http, request, stream, stream_parser, &b)
-        if stream
-          http.request(request) do |res|
-            if Net::HTTPSuccess === res
-              parser = StreamDecoder.new(stream_parser.new(stream))
-              res.read_body(parser)
-              body = parser.body
-              res.body = (Hash === body || Array === body) ? LLM::Object.from(body) : body
-            else
-              body = +""
-              res.read_body { body << _1 }
-              res.body = body
-            end
-          ensure
-            parser&.free
-          end
-        elsif b
-          http.request(request) { (Net::HTTPSuccess === _1) ? b.call(_1) : _1 }
-        else
-          http.request(request)
-        end
-      end
-    end
-  end
-end

data/lib/llm/provider/transport/http/interruptible.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Provider
-  ##
-  # Internal request interruption methods for
-  # {LLM::Provider::Transport::HTTP}.
-  #
-  # This module tracks active requests by execution owner and provides
-  # the logic used to interrupt an in-flight request by closing the
-  # active HTTP connection.
-  #
-  # @api private
-  module Transport::HTTP::Interruptible
-    INTERRUPT_ERRORS = [::IOError, ::EOFError, Errno::EBADF].freeze
-    Request = Struct.new(:http, :connection, keyword_init: true)
-
-    def interrupt_errors
-      [*INTERRUPT_ERRORS, *optional_interrupt_errors]
-    end
-
-    ##
-    # Interrupt an active request, if any.
-    # @param [Fiber] owner
-    #  The execution owner whose request should be interrupted
-    # @return [nil]
-    def interrupt!(owner)
-      req = request_for(owner) or return
-      lock { (@interrupts ||= {})[owner] = true }
-      if persistent_http?(req.http)
-        close_socket(req.connection&.http)
-        req.http.finish(req.connection)
-      elsif transient_http?(req.http)
-        close_socket(req.http)
-        req.http.finish if req.http.active?
-      end
-      owner.stop if owner.respond_to?(:stop)
-    rescue *interrupt_errors
-      nil
-    end
-
-    private
-
-    ##
-    # Closes the active socket for a request, if present.
-    # @param [Net::HTTP, nil] http
-    # @return [nil]
-    def close_socket(http)
-      socket = http&.instance_variable_get(:@socket) or return
-      socket = socket.io if socket.respond_to?(:io)
-      socket.close
-    rescue *interrupt_errors
-      nil
-    end
-
-    ##
-    # Returns whether the active request is using a transient HTTP client.
-    # @param [Object, nil] http
-    # @return [Boolean]
-    def transient_http?(http)
-      Net::HTTP === http
-    end
-
-    ##
-    # Returns whether the active request is using a persistent HTTP client.
-    # @param [Object, nil] http
-    # @return [Boolean]
-    def persistent_http?(http)
-      defined?(Net::HTTP::Persistent) && Net::HTTP::Persistent === http
-    end
-
-    ##
-    # Returns the active request for an execution owner.
-    # @param [Fiber] owner
-    # @return [Request, nil]
-    def request_for(owner)
-      lock do
-        @requests ||= {}
-        @requests[owner]
-      end
-    end
-
-    ##
-    # Records an active request for an execution owner.
-    # @param [Request] req
-    # @param [Fiber] owner
-    # @return [Request]
-    def set_request(req, owner)
-      lock do
-        @requests ||= {}
-        @requests[owner] = req
-      end
-    end
-
-    ##
-    # Clears the active request for an execution owner.
-    # @param [Fiber] owner
-    # @return [Request, nil]
-    def clear_request(owner)
-      lock { @requests&.delete(owner) }
-    end
-
-    ##
-    # Returns whether an execution owner was interrupted.
-    # @param [Fiber] owner
-    # @return [Boolean, nil]
-    def interrupted?(owner)
-      lock { @interrupts&.delete(owner) }
-    end
-
-    def optional_interrupt_errors
-      defined?(::Async::Stop) ? [Async::Stop] : []
-    end
-  end
-end

data/lib/llm/provider/transport/http.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Provider
-  module Transport
-    ##
-    # The {LLM::Provider::Transport::HTTP LLM::Provider::Transport::HTTP}
-    # class manages HTTP connections for {LLM::Provider}. It handles
-    # transient and persistent clients, tracks active requests by owner,
-    # and interrupts in-flight requests when needed.
-    #
-    # @api private
-    class HTTP
-      require_relative "http/stream_decoder"
-      require_relative "http/interruptible"
-
-      include Interruptible
-
-      ##
-      # @param [String] host
-      # @param [Integer] port
-      # @param [Integer] timeout
-      # @param [Boolean] ssl
-      # @param [Boolean] persistent
-      # @return [LLM::Provider::Transport::HTTP]
-      def initialize(host:, port:, timeout:, ssl:, persistent: false)
-        @host = host
-        @port = port
-        @timeout = timeout
-        @ssl = ssl
-        @base_uri = URI("#{ssl ? "https" : "http"}://#{host}:#{port}/")
-        @persistent_client = persistent ? persistent_client : nil
-        @monitor = Monitor.new
-      end
-
-      ##
-      # Interrupt an active request, if any.
-      # @param [Fiber] owner
-      # @return [nil]
-      def interrupt!(owner)
-        super
-      end
-
-      ##
-      # Returns whether an execution owner was interrupted.
-      # @param [Fiber] owner
-      # @return [Boolean, nil]
-      def interrupted?(owner)
-        super
-      end
-
-      ##
-      # Returns the current request owner.
-      # @return [Object]
-      def request_owner
-        return Fiber.current unless defined?(::Async)
-        Async::Task.current? ? Async::Task.current : Fiber.current
-      end
-
-      ##
-      # Configures the transport to use a persistent HTTP connection pool.
-      # @return [LLM::Provider::Transport::HTTP]
-      def persist!
-        client = persistent_client
-        lock do
-          @persistent_client = client
-          self
-        end
-      end
-      alias_method :persistent, :persist!
-
-      ##
-      # @return [Boolean]
-      def persistent?
-        !@persistent_client.nil?
-      end
-
-      ##
-      # Performs a request on the current HTTP transport.
-      # @param [Net::HTTPRequest] request
-      # @param [Fiber] owner
-      # @yieldparam [Net::HTTP] http
-      # @return [Object]
-      def request(request, owner:, &)
-        if persistent?
-          request_persistent(request, owner, &)
-        else
-          request_transient(request, owner, &)
-        end
-      ensure
-        clear_request(owner)
-      end
-
-      ##
-      # @return [String]
-      def inspect
-        "#<#{self.class.name}:0x#{object_id.to_s(16)} @persistent=#{persistent?}>"
-      end
-
-      private
-
-      attr_reader :host, :port, :timeout, :ssl, :base_uri
-
-      def request_transient(request, owner, &)
-        http = transient_client
-        set_request(Request.new(http:), owner)
-        yield http
-      end
-
-      def request_persistent(request, owner, &)
-        persistent_client.connection_for(URI.join(base_uri, request.path)) do |connection|
-          set_request(Request.new(http: persistent_client, connection:), owner)
-          yield connection.http
-        end
-      end
-
-      def persistent_client
-        LLM.lock(:clients) do
-          if LLM.clients[client_id]
-            LLM.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
-            LLM.clients[client_id] = client
-          end
-        end
-      end
-
-      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}"
-      end
-
-      def lock(&)
-        @monitor.synchronize(&)
-      end
-    end
-  end
-end

data/lib/llm/utils.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-##
-# @private
-module LLM::Utils
-  def camelcase(key)
-    key.to_s
-      .split("_")
-      .map.with_index { (_2 > 0) ? _1.capitalize : _1 }
-      .join
-  end
-
-  def snakecase(key)
-    key
-      .split(/([A-Z])/)
-      .map { (_1.size == 1) ? "_#{_1.downcase}" : _1 }
-      .join
-  end
-end