llm.rb 11.1.0 → 11.3.0

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

@@ -72,7 +72,11 @@ module LLM
     #  Returns the current skills when no argument is provided
     def self.skills(*skills, &block)
       return @skills if skills.empty? && !block
-      @skills = block || skills.flatten
+      if skills.size == 1 and skills.grep(Symbol).any?
+        @skills = skills.first
+      else
+        @skills = block || skills.flatten
+      end
     end
 
     ##
@@ -160,14 +164,31 @@ module LLM
     ##
     # Set or get the tool names that require confirmation before they can run.
     #
+    # When a single Symbol is given, it is stored as-is and resolved at
+    # initialization time by calling the method with that name on the agent
+    # instance. This allows dynamic tool confirmation lists.
+    #
+    # @example
+    #   class MyAgent < LLM::Agent
+    #     confirm :tools_that_need_confirmation
+    #
+    #     def tools_that_need_confirmation
+    #       some_condition ? %w[delete destroy] : %w[delete]
+    #     end
+    #   end
+    #
     # @param [String, Symbol, Array<String, Symbol>, Proc] tool_names
     #  One or more tool names.
     # @param [Proc] block
     #  An optional, lazy-evaluated Proc
-    # @return [Array<String>, Proc, nil]
+    # @return [Array<String>, Proc, Symbol, nil]
     def self.confirm(*tool_names, &block)
       return @confirm if tool_names.empty? && !block
-      @confirm = block || tool_names.flatten.map(&:to_s)
+      if tool_names.size == 1 && tool_names.grep(Symbol).any?
+        @confirm = tool_names.first
+      else
+        @confirm = block || tool_names.flatten.map(&:to_s)
+      end
     end
 
     ##
@@ -190,7 +211,7 @@ module LLM
       fields_ivar = %i[tracer concurrency instructions confirm]
       fields.each do |field|
         resolvable = params.key?(field) ? params.delete(field) : self.class.public_send(field)
-        resolve_symbol = !%i[concurrency confirm].include?(field)
+        resolve_symbol = !%i[concurrency].include?(field)
         resolved = resolvable != nil ? resolve_option(self, resolvable, resolve_symbol:) : resolvable
         resolved = [*resolved].map(&:to_s) if field == :confirm && resolved
         if field == :model
@@ -447,10 +468,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/error.rb

@@ -35,6 +35,10 @@ module LLM
   # HTTPServerError
   ServerError = Class.new(Error)
 
+  ##
+  # HTTPNotFound
+  NotFoundError = Class.new(Error)
+
   ##
   # When an given an input object that is not understood
   FormatError = Class.new(Error)

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/error_handler.rb

@@ -49,6 +49,8 @@ class LLM::Anthropic
         LLM::UnauthorizedError.new("Authentication error").tap { _1.response = res }
       elsif res.rate_limited?
         LLM::RateLimitError.new("Too many requests").tap { _1.response = res }
+      elsif res.not_found?
+        LLM::NotFoundError.new("Server response: not found (404)").tap { _1.response = res }
       else
         LLM::Error.new("Unexpected response").tap { _1.response = res }
       end

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/error_handler.rb

@@ -53,7 +53,7 @@ class LLM::Bedrock
       elsif res.rate_limited?
         LLM::RateLimitError.new(message).tap { _1.response = res }
       elsif res.not_found?
-        LLM::Error.new("Bedrock model not found: #{message}").tap { _1.response = res }
+        LLM::NotFoundError.new("Server response: not found (404)").tap { _1.response = res }
       else
         LLM::Error.new(message).tap { _1.response = res }
       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)

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

@@ -8,7 +8,7 @@ class LLM::Bedrock
   # Signs HTTP requests and headers with AWS Signature V4.
   #
   # Returns the signed headers as a Hash through #to_h, ready to merge
-  # into a Net::HTTPRequest or other HTTP client. Everything else is
+  # into an {LLM::Transport::Request} or other HTTP client. Everything else is
   # private.
   #
   # Uses only Ruby's stdlib (openssl, digest) with no external deps.
@@ -89,8 +89,8 @@ class LLM::Bedrock
     end
 
     ##
-    # @param [Net::HTTPRequest] req
-    # @return [Net::HTTPRequest]
+    # @param [LLM::Transport::Request] req
+    # @return [LLM::Transport::Request]
     def sign!(req)
       to_h.each { |k, v| req[k] = v }
       req

data/lib/llm/providers/bedrock.rb

@@ -217,7 +217,7 @@ module LLM
       body = LLM.json.dump(payload)
       path = stream ? "/model/#{model_id}/converse-stream" \
                     : "/model/#{model_id}/converse"
-      req = Net::HTTP::Post.new(path, headers)
+      req = LLM::Transport::Request.post(path, headers)
       transport.set_body_stream(req, StringIO.new(body))
       [req, messages, body]
     end

data/lib/llm/providers/google/error_handler.rb

@@ -60,6 +60,8 @@ class LLM::Google
         end
       elsif res.rate_limited?
         LLM::RateLimitError.new("Too many requests").tap { _1.response = res }
+      elsif res.not_found?
+        LLM::NotFoundError.new("Server response: not found (404)").tap { _1.response = res }
       else
         LLM::Error.new("Unexpected response").tap { _1.response = res }
       end

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

@@ -45,7 +45,7 @@ class LLM::Google
     # @return [LLM::Response]
     def all(**params)
       query = URI.encode_www_form(params.merge!(key: key))
-      req = Net::HTTP::Get.new("/v1beta/files?#{query}", headers)
+      req = LLM::Transport::Request.get("/v1beta/files?#{query}", headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = ResponseAdapter.adapt(res, type: :files)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -64,7 +64,7 @@ class LLM::Google
     # @return [LLM::Response]
     def create(file:, **params)
       file = LLM.File(file)
-      req = Net::HTTP::Post.new(request_upload_url(file:), {})
+      req = LLM::Transport::Request.post(request_upload_url(file:), {})
       req["content-length"] = file.bytesize
       req["X-Goog-Upload-Offset"] = 0
       req["X-Goog-Upload-Command"] = "upload, finalize"
@@ -91,7 +91,7 @@ class LLM::Google
     def get(file:, **params)
       file_id = file.respond_to?(:name) ? file.name : file.to_s
       query = URI.encode_www_form(params.merge!(key: key))
-      req = Net::HTTP::Get.new("/v1beta/#{file_id}?#{query}", headers)
+      req = LLM::Transport::Request.get("/v1beta/#{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:)
@@ -111,7 +111,7 @@ class LLM::Google
     def delete(file:, **params)
       file_id = file.respond_to?(:name) ? file.name : file.to_s
       query = URI.encode_www_form(params.merge!(key: key))
-      req = Net::HTTP::Delete.new("/v1beta/#{file_id}?#{query}", headers)
+      req = LLM::Transport::Request.delete("/v1beta/#{file_id}?#{query}", headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -128,7 +128,7 @@ class LLM::Google
     private
 
     def request_upload_url(file:)
-      req = Net::HTTP::Post.new("/upload/v1beta/files?key=#{key}", headers)
+      req = LLM::Transport::Request.post("/upload/v1beta/files?key=#{key}", headers)
       req["X-Goog-Upload-Protocol"] = "resumable"
       req["X-Goog-Upload-Command"] = "start"
       req["X-Goog-Upload-Header-Content-Length"] = file.bytesize

data/lib/llm/providers/google/images.rb

@@ -40,7 +40,7 @@ class LLM::Google
     # @raise (see LLM::Provider#request)
     # @return [LLM::Response]
     def create(prompt:, n: 1, image_size: nil, aspect_ratio: nil, person_generation: nil, model: "imagen-4.0-generate-001", **params)
-      req  = Net::HTTP::Post.new("/v1beta/models/#{model}:predict?key=#{key}", headers)
+      req  = LLM::Transport::Request.post("/v1beta/models/#{model}:predict?key=#{key}", headers)
       body = LLM.json.dump({
         parameters: {
           sampleCount: n,