llm.rb 11.1.0 → 11.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bb91948d8cfa006f7512dd0a4fa62f90b42360e3f11a57074870470fdc70d3f
-  data.tar.gz: 64b49f633318bc0439252cebca4c3886db4c7676f3cb9a78f4945eefe58b4356
+  metadata.gz: bb1ffd1e0ecb17422014ec8f75c8b729f74d0a7cef4fd4e12681ef254411b24a
+  data.tar.gz: e5a7815d52c6fa99a38dec111c6d71aef9782272b97bfbad81e8f5bee913f918
 SHA512:
-  metadata.gz: c56b48185604b22c44f7b4697da56a5fda8359a69e110392abf2510b47a4dc9aedbe5c6a9e64e733fafb5672c34d4a0833448fab5ca9de52c453c8a906080174
-  data.tar.gz: a2a9241da0e8749569111573451c99c92ed3569fa7cee0c9178b8aa884a72b27a24f18e19566cef8a16c2e460420a392b83d441708da67a571a9e2648d4d81e2
+  metadata.gz: d7c2d1dac8ef97a5be2540896828b523ce1491e43f2fd8c78e53b8fbab34432bf6dedaee066afd43d261fb8f4e2fb9f7c3d8c112de83e60ee809d6ef77f41feb
+  data.tar.gz: d5073e8c5c156739cff4c68c65c4efaf88403229841ada3cdd1adb4920dfb58c00017ae7dbd73d12ef17b6c191b0b71ab4f15fd0c0ae29991dcffb1b840381d0

data/CHANGELOG.md

@@ -2,6 +2,89 @@
 
 ## Unreleased
 
+## v11.2.0
+
+Changes since `v11.1.0`.
+
+This release adds `LLM::Function#skill?` and `LLM::Tool#skill?` so
+callers can inspect whether a function or tool is backed by a skill.
+
+It introduces `LLM::Transport::Request` as a transport-agnostic request
+object so providers no longer depend directly on `Net::HTTP` request
+classes, and adds an optional Curb (libcurl) backend alongside symbolic
+transport shortcuts such as `transport: :curb`.
+
+MCP and A2A clients now accept `persistent: true` matching provider configuration.
+Several fixes land for tool return callback emission, function comparison by
+tool call ID, function array filtering, skill tool inheritance, and JSON generator
+state compatibility on Ruby 4.
+
+### Add
+
+* **Add `LLM::Function#skill?`** <br>
+  Add `skill?` to `LLM::Function` so callers can check whether a
+  function is backed by a skill tool.
+
+* **Add `LLM::Tool.skill?` and `LLM::Tool#skill?`** <br>
+  Add class-level `skill?` and instance-level `skill?` to
+  `LLM::Tool`, matching the existing `mcp?` and `a2a?` pattern.
+
+* **Add `LLM::Transport::Request`** <br>
+  Add `LLM::Transport::Request` as a transport-agnostic request object
+  and update providers to build requests without depending directly on
+  Net::HTTP request classes. The built-in Net::HTTP transports still
+  accept existing Net::HTTP request objects through a compatibility
+  bridge, while alternative transports can handle the generic request
+  shape directly.
+
+* **Add optional Curb transport support** <br>
+  Add `LLM::Transport::Curb`, an optional libcurl-backed transport
+  that can be selected with `transport: :curb`. Providers already
+  emit `LLM::Transport::Request` objects, so the Curb backend can
+  execute requests without routing through Net::HTTP.
+
+* **Add symbolic transport shortcuts** <br>
+  Allow providers, MCP HTTP clients, and A2A HTTP clients to accept
+  transport shortcuts such as `transport: :curb` and
+  `transport: :net_http_persistent`.
+
+* **Add persistent HTTP selection to MCP and A2A clients** <br>
+  Allow MCP and A2A HTTP clients to accept `persistent: true`, matching
+  provider configuration and selecting the persistent Net::HTTP
+  transport by default.
+
+### Fix
+
+* **Support JSON generation state on Ruby 4** <br>
+  Handle JSON generator state objects in the standard JSON adapter so
+  schema objects serialize correctly when Ruby 4 calls custom `to_json`
+  methods during provider request generation.
+
+* **Emit tool return callbacks for direct context waits** <br>
+  Emit `LLM::Stream#on_tool_return` when `LLM::Context#wait` executes
+  pending tool work directly instead of draining `LLM::Stream::Queue`.
+
+* **Emit confirmed tool return callbacks once** <br>
+  Emit `LLM::Stream#on_tool_return` for confirmed and cancelled tool
+  calls, and exclude confirmed functions from later waits so mixed
+  confirmed and unconfirmed tool batches do not execute confirmed tools
+  twice.
+
+* **Compare functions by tool call ID** <br>
+  Add `LLM::Function#==`, `#eql?`, and `#hash` so pending function
+  collections can compare tool calls by provider-assigned ID instead of
+  object identity.
+
+* **Preserve function array behavior after filtering** <br>
+  Preserve `LLM::Function::Array` behavior when subtracting function
+  arrays so filtered tool batches can still spawn through the normal
+  function array API.
+
+* **Prevent skills from inheriting skill-backed tools** <br>
+  Exclude skill-backed tools when a skill sub-agent uses `tools:
+  inherit`, preventing skills loaded through a parent context from
+  being recursively exposed to nested skill agents.
+
 ## v11.1.0
 
 Changes since `v11.0.0`.
@@ -133,7 +216,7 @@ requests outside `#session`, `LLM::Function#def` as a short alias for
 
 * **Fix context and agent JSON serialization through `LLM.json`** <br>
   Fix `LLM::Context#to_json` and `LLM::Agent#to_json` to serialize
-  through `LLM.json.dump(...)` instead of plain `to_json`. 
+  through `LLM.json.dump(...)` instead of plain `to_json`.
 
 * **Fix block-form ORM agent DSL forwarding** <br>
   Fix block-form `model { ... }`, `tools { ... }`, and

data/README.md

@@ -11,7 +11,7 @@
     <img src="https://img.shields.io/badge/License-0BSD-orange.svg?" alt="License">
   </a>
   <a href="https://github.com/llmrb/llm.rb/tags">
-    <img src="https://img.shields.io/badge/version-11.1.0-green.svg?" alt="Version">
+    <img src="https://img.shields.io/badge/version-11.2.0-green.svg?" alt="Version">
   </a>
 </p>
 
@@ -175,7 +175,9 @@ ctx.talk(ctx.wait(:call)) while ctx.functions?
 The HTTP transport can be used with or without the `session` method,
 and unlike the stdio transport it can remain efficient without the
 `session` method through a persistent connection pool that is available
-through the [LLM::Transport.net_http_persistent](https://0x1eef.github.io/x/llm.rb/LLM/Transport.html#method-c-net_http_persistent) transport:
+through the
+[LLM::Transport.net_http_persistent](https://0x1eef.github.io/x/llm.rb/LLM/Transport.html#method-c-net_http_persistent)
+transport:
 
 ```ruby
 require "llm"
@@ -183,7 +185,7 @@ require "llm"
 llm = LLM.openai(key: ENV["KEY"])
 mcp = LLM::MCP.http(
   url: "https://remote-mcp.example.com",
-  transport: LLM::Transport.net_http_persistent
+  transport: :net_http_persistent
 )
 
 ctx = LLM::Context.new(llm, tools: mcp.tools)
@@ -224,7 +226,7 @@ require "llm"
 
 a2a = LLM::A2A.rest(
   url: "https://remote-agent.example.com",
-  transport: LLM::Transport.net_http_persistent
+  transport: :net_http_persistent
 )
 ```
 
@@ -232,6 +234,27 @@ For more on direct messaging, task operations, push notification
 configs, and JSON-RPC, see the
 [LLM::A2A API docs](https://0x1eef.github.io/x/llm.rb/LLM/A2A.html).
 
+#### Transports
+
+Providers use Ruby's standard library Net::HTTP transport by default.
+You can opt into persistent Net::HTTP connections with `persistent: true`,
+or provide a transport shortcut when you want a different backend.
+`transport: :curb` uses libcurl through the optional `curb` gem.
+
+Custom transports can implement the
+[LLM::Transport](https://0x1eef.github.io/x/llm.rb/LLM/Transport.html)
+interface and receive transport-agnostic
+[LLM::Transport::Request](https://0x1eef.github.io/x/llm.rb/LLM/Transport/Request.html)
+objects from providers.
+
+```ruby
+require "llm"
+
+llm = LLM.openai(key: ENV["KEY"], persistent: true)
+llm = LLM.openai(key: ENV["KEY"], transport: :net_http_persistent)
+llm = LLM.openai(key: ENV["KEY"], transport: :curb)
+```
+
 #### Skills
 
 Skills are reusable instructions loaded from a `SKILL.md` directory. They let

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

@@ -17,13 +17,14 @@ class LLM::A2A
       # @param [String] url The base URL of the A2A agent
       # @param [Hash<String, String>] headers Extra HTTP headers
       # @param [Integer, nil] timeout The timeout in seconds
-      # @param [LLM::Transport, Class, nil] transport Override transport
+      # @param [Boolean] persistent Whether to use persistent HTTP connections
+      # @param [LLM::Transport, Class, Symbol, nil] transport Override transport
       # @param [String] protocol_version The A2A protocol version header
-      def initialize(url:, headers: {}, timeout: nil, transport: nil, protocol_version: "1.0")
+      def initialize(url:, headers: {}, timeout: nil, persistent: false, transport: nil, protocol_version: "1.0")
         @uri = URI.parse(url)
         @headers = headers
         @protocol_version = protocol_version
-        @transport = resolve_transport(@uri, transport, timeout)
+        @transport = resolve_transport(host: @uri.host, port: uri.port, ssl: @uri.scheme == "https", timeout:, persistent:, transport:)
       end
 
       ##
@@ -31,7 +32,7 @@ class LLM::A2A
       # @param [String] path The URL path
       # @return [Hash]
       def get(path, accept: "application/json")
-        req = Net::HTTP::Get.new(request_path(path), headers(accept:))
+        req = LLM::Transport::Request.get(request_path(path), headers(accept:))
         res = transport.request(req, owner: self)
         parse_response(res)
       end
@@ -42,7 +43,7 @@ class LLM::A2A
       # @param [Hash] body The JSON body
       # @return [Hash]
       def post(path, body, content_type: "application/json", accept: "application/json")
-        req = Net::HTTP::Post.new(request_path(path), headers(content_type:, accept:))
+        req = LLM::Transport::Request.post(request_path(path), headers(content_type:, accept:))
         req.body = LLM.json.dump(body)
         res = transport.request(req, owner: self)
         parse_response(res)
@@ -53,7 +54,7 @@ class LLM::A2A
       # @param [String] path The URL path
       # @return [Hash]
       def delete(path, accept: "application/json")
-        req = Net::HTTP::Delete.new(request_path(path), headers(accept:))
+        req = LLM::Transport::Request.delete(request_path(path), headers(accept:))
         res = transport.request(req, owner: self)
         parse_response(res)
       end
@@ -66,7 +67,7 @@ class LLM::A2A
       # @yieldparam [LLM::Object] event A stream event
       # @return [void]
       def get_stream(path, &on_event)
-        req = Net::HTTP::Get.new(request_path(path), headers(accept: "text/event-stream"))
+        req = LLM::Transport::Request.get(request_path(path), headers(accept: "text/event-stream"))
         stream(req, &on_event)
       end
 
@@ -79,7 +80,7 @@ class LLM::A2A
       # @yieldparam [LLM::Object] event A stream event
       # @return [void]
       def post_stream(path, body, content_type: "application/json", &on_event)
-        req = Net::HTTP::Post.new(request_path(path), headers(content_type:, accept: "text/event-stream"))
+        req = LLM::Transport::Request.post(request_path(path), headers(content_type:, accept: "text/event-stream"))
         req.body = LLM.json.dump(body)
         stream(req, &on_event)
       end

data/lib/llm/a2a.rb

@@ -61,8 +61,10 @@ class LLM::A2A
   #  Extra HTTP headers to include in requests (e.g., Authorization)
   # @param [Integer, nil] timeout
   #  The timeout in seconds for HTTP requests
-  # @param [LLM::Transport, Class, nil] transport
-  #  Optional override with any {LLM::Transport} instance or subclass
+  # @param [Boolean] persistent
+  #  Whether to use persistent HTTP connections
+  # @param [LLM::Transport, Class, Symbol, nil] transport
+  #  Optional override with any {LLM::Transport} instance, subclass, or shortcut
   # @param [Symbol] binding
   #  The protocol binding to use. One of `:rest` or `:jsonrpc`
   # @param [String] base_path
@@ -70,7 +72,7 @@ class LLM::A2A
   # @param [String] protocol_version
   #  The expected A2A protocol version. Defaults to `"1.0"`.
   # @return [LLM::A2A]
-  def self.http(url:, headers: {}, timeout: 30, transport: nil, binding: :rest, base_path: "", protocol_version: "1.0")
+  def self.http(url:, headers: {}, timeout: 30, persistent: false, transport: nil, binding: :rest, base_path: "", protocol_version: "1.0")
     new(
       binding:,
       base_path:,
@@ -79,6 +81,7 @@ class LLM::A2A
         url:,
         headers:,
         timeout:,
+        persistent:,
         transport:,
         protocol_version:
       )
@@ -90,13 +93,15 @@ class LLM::A2A
   # @param [String] url
   # @param [Hash<String, String>] headers
   # @param [Integer, nil] timeout
-  # @param [LLM::Transport, Class, nil] transport
+  # @param [Boolean] persistent
+  # @param [LLM::Transport, Class, Symbol, nil] transport
   # @return [LLM::A2A]
-  def self.rest(url:, headers: {}, timeout: 30, transport: nil, base_path: "", protocol_version: "1.0")
+  def self.rest(url:, headers: {}, timeout: 30, persistent: false, transport: nil, base_path: "", protocol_version: "1.0")
     http(
       url:,
       headers:,
       timeout:,
+      persistent:,
       transport:,
       binding: :rest,
       base_path:,
@@ -109,13 +114,15 @@ class LLM::A2A
   # @param [String] url
   # @param [Hash<String, String>] headers
   # @param [Integer, nil] timeout
-  # @param [LLM::Transport, Class, nil] transport
+  # @param [Boolean] persistent
+  # @param [LLM::Transport, Class, Symbol, nil] transport
   # @return [LLM::A2A]
-  def self.jsonrpc(url:, headers: {}, timeout: 30, transport: nil, base_path: "", protocol_version: "1.0")
+  def self.jsonrpc(url:, headers: {}, timeout: 30, persistent: false, transport: nil, base_path: "", protocol_version: "1.0")
     http(
       url:,
       headers:,
       timeout:,
+      persistent:,
       transport:,
       binding: :jsonrpc,
       base_path:,

data/lib/llm/agent.rb

@@ -447,10 +447,13 @@ module LLM
       strategy = concurrency || :call
       return wait(strategy) unless @confirm&.any?
       confirmables = @ctx.functions.select { @confirm.include?(_1.name.to_s) }
-      results = confirmables.map do |tool|
-        send(:on_tool_confirmation, tool, strategy)
+      results = confirmables.map { method(:on_tool_confirmation).call(_1, strategy) }
+      @ctx.method(:emit_tool_returns).call(confirmables, results)
+      if (@ctx.functions - confirmables).any?
+        [*results, *wait(strategy, except: confirmables)]
+      else
+        results
       end
-      @ctx.functions? ? [*results, *wait(strategy)] : results
     end
 
     ##

data/lib/llm/context.rb

@@ -303,15 +303,21 @@ module LLM
     #  without using this argument.
     #  Otherwise, this controls how pending functions are resolved directly.
     #  Use `:call` for sequential execution without spawning.
+    # @param [Array<LLM::Function>] except
+    #  A list of functions to exclude from the wait
     # @return [Array<LLM::Function::Return>]
-    def wait(strategy)
+    def wait(strategy, except: [])
       if LLM::Stream === stream && !stream.queue.empty?
         @queue = stream.queue
         @queue.wait
       else
-        return guarded_returns if guarded_returns
-        @queue = functions.spawn(strategy)
-        @queue.wait
+        tools  = except.empty? ? functions : functions - except
+        guards = guarded_returns(tools:)
+        return guards if guards
+        @queue = tools.spawn(strategy)
+        returns = @queue.wait
+        emit_tool_returns(tools, returns)
+        returns
       end
     ensure
       @queue = nil
@@ -516,10 +522,10 @@ module LLM
     ##
     # Builds in-band guarded returns when the guard blocks tool work.
     # @api private
-    def guarded_returns
+    def guarded_returns(tools:)
       warning = guard&.call(self)
       return unless warning
-      functions.map { guarded_return_for(_1, warning) }
+      tools.map { guarded_return_for(_1, warning) }
     end
 
     ##
@@ -568,6 +574,14 @@ module LLM
       })
     end
 
+    ##
+    # Emits tool return callbacks for directly waited function work.
+    # @api private
+    def emit_tool_returns(tools, returns)
+      return unless LLM::Stream === stream
+      returns.each_with_index { |result, index| stream.on_tool_return(tools[index], result) }
+    end
+
     ##
     # Closes assistant tool-call messages that do not have matching tool
     # responses. This can happen when a turn is interrupted while a tool

data/lib/llm/function/array.rb

@@ -68,5 +68,11 @@ class LLM::Function
     def wait(strategy)
       spawn(strategy).wait
     end
+
+    ##
+    # @return [LLM::Function::Array]
+    def -(other)
+      super.extend(Array)
+    end
   end
 end

data/lib/llm/function.rb

@@ -120,6 +120,25 @@ class LLM::Function
     @arguments = LLM::Object.from(other)
   end
 
+  ##
+  # Compares functions by tool call ID when both sides have one.
+  # @param [LLM::Function] other
+  # @return [Boolean]
+  def ==(other)
+    return true if equal?(other)
+    return false unless self.class === other
+    return false unless id && other.id
+    id == other.id
+  end
+  alias_method :eql?, :==
+
+  ##
+  # Returns a hash value compatible with {#==}.
+  # @return [Integer]
+  def hash
+    id ? id.hash : object_id.hash
+  end
+
   ##
   # Returns a tracer, or nil
   # @return [LLM::Tracer, nil]
@@ -300,6 +319,13 @@ class LLM::Function
     @cancelled
   end
 
+  ##
+  # Returns true when this function is backed by a skill tool.
+  # @return [Boolean]
+  def skill?
+    @runner.respond_to?(:skill?) and @runner.skill?
+  end
+
   ##
   # Returns true when a function has neither been called nor cancelled
   # @return [Boolean]

data/lib/llm/json_adapter.rb

@@ -35,9 +35,15 @@ module LLM
   class JSONAdapter::JSON < JSONAdapter
     ##
     # @return (see JSONAdapter#dump)
-    def self.dump(obj, ...)
+    def self.dump(obj, state = nil, **options)
       require "json" unless defined?(::JSON)
-      ::JSON.dump(obj, ...)
+      if ::JSON::State === state
+        ::JSON.generate(obj, state)
+      elsif state
+        ::JSON.dump(obj, state, **options)
+      else
+        ::JSON.dump(obj, **options)
+      end
     end
 
     ##

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

@@ -16,16 +16,18 @@ module LLM::MCP::Transport
     #  Extra headers to send with requests
     # @param [Integer, nil] timeout
     #  The timeout in seconds. Defaults to nil
-    # @param [LLM::Transport, Class, nil] transport
-    #  Optional override with any {LLM::Transport} instance or subclass
+    # @param [Boolean] persistent
+    #  Whether to use persistent HTTP connections
+    # @param [LLM::Transport, Class, Symbol, nil] transport
+    #  Optional override with any {LLM::Transport} instance, subclass, or shortcut
     # @return [LLM::MCP::Transport::HTTP]
-    def initialize(url:, headers: {}, timeout: nil, transport: nil)
+    def initialize(url:, headers: {}, timeout: nil, persistent: false, transport: nil)
       @uri = URI.parse(url)
       @headers = headers
-      @transport = resolve_transport(uri, transport, timeout)
       @queue = []
       @monitor = Monitor.new
       @running = false
+      @transport = resolve_transport(host: uri.host, port: uri.port, ssl: uri.scheme == "https", timeout:, persistent:, transport:)
     end
 
     ##
@@ -62,7 +64,7 @@ module LLM::MCP::Transport
     # @return [void]
     def write(message)
       raise LLM::MCP::Error, "MCP transport is not running" unless running?
-      req = Net::HTTP::Post.new(uri.request_uri, headers.merge("content-type" => "application/json"))
+      req = LLM::Transport::Request.post(uri.request_uri, headers.merge("content-type" => "application/json"))
       req.body = LLM.json.dump(message)
       res = transport.request(req, owner: self) { consume(_1) }
       res = LLM::Transport::Response.from(res)

data/lib/llm/mcp.rb

@@ -55,9 +55,11 @@ class LLM::MCP
   #  The URL for the MCP HTTP endpoint
   # @option http [Hash] :headers
   #  Extra headers for requests
-  # @option http [LLM::Transport, Class] :transport
-  #  Optional override with any {LLM::Transport} instance or subclass,
-  #  similar to {LLM::Provider}
+  # @option http [Boolean] :persistent
+  #  Whether to use persistent HTTP connections
+  # @option http [LLM::Transport, Class, Symbol] :transport
+  #  Optional override with any {LLM::Transport} instance, subclass, or
+  #  shortcut, similar to {LLM::Provider}
   # @param [Integer] timeout
   #  The maximum amount of time to wait when reading from an MCP process
   # @return [LLM::MCP] A new MCP instance
@@ -69,10 +71,7 @@ class LLM::MCP
       @command = Command.new(**stdio)
       @transport = Transport::Stdio.new(command:)
     elsif http
-      persistent = http.delete(:persistent)
-      transport = http.delete(:transport)
-      transport ||= LLM::Transport::PersistentHTTP if persistent
-      @transport = Transport::HTTP.new(**http, timeout:, transport:)
+      @transport = Transport::HTTP.new(**http, timeout:)
     else
       raise ArgumentError, "stdio or http is required"
     end

data/lib/llm/provider.rb

@@ -35,7 +35,7 @@ class LLM::Provider
     @base_path = LLM::Utils.normalize_base_path(base_path)
     @base_uri = URI("#{ssl ? "https" : "http"}://#{host}:#{port}/")
     @headers = {"User-Agent" => "llm.rb v#{LLM::VERSION}"}
-    @transport = resolve_transport(transport, persistent:)
+    @transport = LLM::Transport::Utils.resolve_transport(host:, port:, timeout:, ssl:, transport:, persistent:)
     @monitor = Monitor.new
   end
 
@@ -417,23 +417,6 @@ class LLM::Provider
     @monitor.synchronize(&)
   end
 
-  ##
-  # @api private
-  def default_transport(persistent:)
-    transport_class = persistent ? LLM::Transport::PersistentHTTP : LLM::Transport::HTTP
-    transport_class.new(host:, port:, timeout:, ssl:)
-  end
-
-  ##
-  # @api private
-  def resolve_transport(transport, persistent:)
-    return default_transport(persistent:) if transport.nil?
-    if Class === transport && transport <= LLM::Transport
-      return transport.new(host:, port:, timeout:, ssl:)
-    end
-    transport
-  end
-
   ##
   # @api private
   def thread

data/lib/llm/providers/anthropic/files.rb

@@ -37,7 +37,7 @@ class LLM::Anthropic
     # @return [LLM::Response]
     def all(**params)
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new("/v1/files?#{query}", headers)
+      req = LLM::Transport::Request.get("/v1/files?#{query}", headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = ResponseAdapter.adapt(res, type: :enumerable)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -56,7 +56,7 @@ class LLM::Anthropic
     # @return [LLM::Response]
     def create(file:, **params)
       multi = LLM::Multipart.new(params.merge!(file: LLM.File(file)))
-      req = Net::HTTP::Post.new("/v1/files", headers)
+      req = LLM::Transport::Request.post("/v1/files", headers)
       req["content-type"] = multi.content_type
       transport.set_body_stream(req, multi.body)
       res, span, tracer = execute(request: req, operation: "request")
@@ -79,7 +79,7 @@ class LLM::Anthropic
     def get(file:, **params)
       file_id = file.respond_to?(:id) ? file.id : file
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new("/v1/files/#{file_id}?#{query}", headers)
+      req = LLM::Transport::Request.get("/v1/files/#{file_id}?#{query}", headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = ResponseAdapter.adapt(res, type: :file)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -100,7 +100,7 @@ class LLM::Anthropic
     def get_metadata(file:, **params)
       query = URI.encode_www_form(params)
       file_id = file.respond_to?(:id) ? file.id : file
-      req = Net::HTTP::Get.new("/v1/files/#{file_id}?#{query}", headers)
+      req = LLM::Transport::Request.get("/v1/files/#{file_id}?#{query}", headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = ResponseAdapter.adapt(res, type: :file)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -120,7 +120,7 @@ class LLM::Anthropic
     # @return [LLM::Response]
     def delete(file:)
       file_id = file.respond_to?(:id) ? file.id : file
-      req = Net::HTTP::Delete.new("/v1/files/#{file_id}", headers)
+      req = LLM::Transport::Request.delete("/v1/files/#{file_id}", headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -145,7 +145,7 @@ class LLM::Anthropic
     def download(file:, **params)
       query = URI.encode_www_form(params)
       file_id = file.respond_to?(:id) ? file.id : file
-      req = Net::HTTP::Get.new("/v1/files/#{file_id}/content?#{query}", headers)
+      req = LLM::Transport::Request.get("/v1/files/#{file_id}/content?#{query}", headers)
       io = StringIO.new("".b)
       res, span, tracer = execute(request: req, operation: "request") { |res| res.read_body { |chunk| io << chunk } }
       res = LLM::Response.new(res).tap { _1.define_singleton_method(:file) { io } }

data/lib/llm/providers/anthropic/models.rb

@@ -39,7 +39,7 @@ class LLM::Anthropic
     # @return [LLM::Response]
     def all(**params)
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new("/v1/models?#{query}", headers)
+      req = LLM::Transport::Request.get("/v1/models?#{query}", headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = ResponseAdapter.adapt(res, type: :models)
       tracer.on_request_finish(operation: "request", res:, span:)

data/lib/llm/providers/anthropic.rb

@@ -160,7 +160,7 @@ module LLM
       messages = build_complete_messages(prompt, params, role)
       payload = adapt(messages)
       body = LLM.json.dump(payload.merge!(params))
-      req = Net::HTTP::Post.new("/v1/messages", headers)
+      req = LLM::Transport::Request.post("/v1/messages", headers)
       transport.set_body_stream(req, StringIO.new(body))
       req
     end

data/lib/llm/providers/bedrock/models.rb

@@ -57,13 +57,13 @@ class LLM::Bedrock
     ##
     # @param [String] host
     # @param [Hash] params
-    # @return [Net::HTTP::Get]
+    # @return [LLM::Transport::Request]
     def build_request(host, params)
       path = "/foundation-models"
       query = URI.encode_www_form(params) unless params.empty?
       path = "#{path}?#{query}" if query && !query.empty?
       body = ""
-      req = Net::HTTP::Get.new(path, {"Content-Type" => "application/json", "Accept" => "application/json"})
+      req = LLM::Transport::Request.get(path, {"Content-Type" => "application/json", "Accept" => "application/json"})
       req.tap { sign!(req, body, host, query) }
     end
 
@@ -84,11 +84,11 @@ class LLM::Bedrock
     end
 
     ##
-    # @param [Net::HTTPRequest] req
+    # @param [LLM::Transport::Request] req
     # @param [String] body
     # @param [String] host
     # @param [String, nil] query
-    # @return [Net::HTTPRequest]
+    # @return [LLM::Transport::Request]
     def sign!(req, body, host = credentials.host, query = nil)
       creds = credentials.tap { _1.host = host }
       Signature.new(credentials: creds, method: "GET", path: "/foundation-models", query:, body:).sign!(req)