llm.rb 11.1.0 → 11.3.0

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

@@ -39,7 +39,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/models?#{query}", headers)
+      req = LLM::Transport::Request.get("/v1beta/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/google.rb

@@ -56,7 +56,7 @@ module LLM
     def embed(input, model: "gemini-embedding-001", **params)
       model = model.respond_to?(:id) ? model.id : model
       path = ["/v1beta/models/#{model}", "embedContent?key=#{@key}"].join(":")
-      req = Net::HTTP::Post.new(path, headers)
+      req = LLM::Transport::Request.post(path, headers)
       req.body = LLM.json.dump({content: {parts: [{text: input}]}})
       res, span, tracer = execute(request: req, operation: "embeddings", model:)
       res = ResponseAdapter.adapt(res, type: :embedding)
@@ -205,7 +205,7 @@ module LLM
       action = stream ? "streamGenerateContent?key=#{@key}&alt=sse" : "generateContent?key=#{@key}"
       model.respond_to?(:id) ? model.id : model
       path = ["/v1beta/models/#{model}", action].join(":")
-      req  = Net::HTTP::Post.new(path, headers)
+      req  = LLM::Transport::Request.post(path, headers)
       messages = build_complete_messages(prompt, params, role)
       body = LLM.json.dump({contents: adapt(messages)}.merge!(params))
       transport.set_body_stream(req, StringIO.new(body))

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

@@ -49,6 +49,8 @@ class LLM::Ollama
         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/ollama/models.rb

@@ -40,7 +40,7 @@ class LLM::Ollama
     # @return [LLM::Response]
     def all(**params)
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new("/api/tags?#{query}", headers)
+      req = LLM::Transport::Request.get("/api/tags?#{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/ollama.rb

@@ -48,7 +48,7 @@ module LLM
     # @return [LLM::Response]
     def embed(input, model: default_model, **params)
       params   = {model:}.merge!(params)
-      req      = Net::HTTP::Post.new("/v1/embeddings", headers)
+      req      = LLM::Transport::Request.post("/v1/embeddings", headers)
       req.body = LLM.json.dump({input:}.merge!(params))
       res, span, tracer = execute(request: req, operation: "embeddings", model:)
       res = ResponseAdapter.adapt(res, type: :embedding)
@@ -129,7 +129,7 @@ module LLM
     def build_complete_request(prompt, params, role)
       messages = build_complete_messages(prompt, params, role)
       body = LLM.json.dump({messages: [adapt(messages)].flatten}.merge!(params))
-      req = Net::HTTP::Post.new("/api/chat", headers)
+      req = LLM::Transport::Request.post("/api/chat", headers)
       transport.set_body_stream(req, StringIO.new(body))
       req
     end

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

@@ -32,7 +32,7 @@ class LLM::OpenAI
     # @raise (see LLM::Provider#request)
     # @return [LLM::Response]
     def create_speech(input:, voice: "alloy", model: "gpt-4o-mini-tts", response_format: "mp3", **params)
-      req = Net::HTTP::Post.new(path("/audio/speech"), headers)
+      req = LLM::Transport::Request.post(path("/audio/speech"), headers)
       req.body = LLM.json.dump({input:, voice:, model:, response_format:}.merge!(params))
       io = StringIO.new("".b)
       res, span, tracer = execute(request: req, operation: "request") { _1.read_body { |chunk| io << chunk } }
@@ -55,7 +55,7 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def create_transcription(file:, model: "whisper-1", **params)
       multi = LLM::Multipart.new(params.merge!(file: LLM.File(file), model:))
-      req = Net::HTTP::Post.new(path("/audio/transcriptions"), headers)
+      req = LLM::Transport::Request.post(path("/audio/transcriptions"), 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::OpenAI
     # @return [LLM::Response]
     def create_translation(file:, model: "whisper-1", **params)
       multi = LLM::Multipart.new(params.merge!(file: LLM.File(file), model:))
-      req = Net::HTTP::Post.new(path("/audio/translations"), headers)
+      req = LLM::Transport::Request.post(path("/audio/translations"), headers)
       req["content-type"] = multi.content_type
       transport.set_body_stream(req, multi.body)
       res, span, tracer = execute(request: req, operation: "request")

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

@@ -55,6 +55,8 @@ class LLM::OpenAI
         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
         error = body["error"] || {}
         case error["type"]

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

@@ -40,7 +40,7 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def all(**params)
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new(path("/files?#{query}"), headers)
+      req = LLM::Transport::Request.get(path("/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:)
@@ -60,7 +60,7 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def create(file:, purpose: "assistants", **params)
       multi = LLM::Multipart.new(params.merge!(file: LLM.File(file), purpose:))
-      req = Net::HTTP::Post.new(path("/files"), headers)
+      req = LLM::Transport::Request.post(path("/files"), headers)
       req["content-type"] = multi.content_type
       transport.set_body_stream(req, multi.body)
       res, span, tracer = execute(request: req, operation: "request")
@@ -83,7 +83,7 @@ class LLM::OpenAI
     def get(file:, **params)
       file_id = file.respond_to?(:id) ? file.id : file
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new(path("/files/#{file_id}?#{query}"), headers)
+      req = LLM::Transport::Request.get(path("/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:)
@@ -105,7 +105,7 @@ class LLM::OpenAI
     def download(file:, **params)
       query = URI.encode_www_form(params)
       file_id = file.respond_to?(:id) ? file.id : file
-      req = Net::HTTP::Get.new(path("/files/#{file_id}/content?#{query}"), headers)
+      req = LLM::Transport::Request.get(path("/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 } }
@@ -125,7 +125,7 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def delete(file:)
       file_id = file.respond_to?(:id) ? file.id : file
-      req = Net::HTTP::Delete.new(path("/files/#{file_id}"), headers)
+      req = LLM::Transport::Request.delete(path("/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:)

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

@@ -50,7 +50,7 @@ class LLM::OpenAI
     # @raise (see LLM::Provider#request)
     # @return [LLM::Response]
     def create(prompt:, model: "dall-e-3", response_format: "b64_json", **params)
-      req = Net::HTTP::Post.new(path("/images/generations"), headers)
+      req = LLM::Transport::Request.post(path("/images/generations"), headers)
       req.body = LLM.json.dump({prompt:, n: 1, model:, response_format:}.merge!(params))
       res, span, tracer = execute(request: req, operation: "request")
       res = ResponseAdapter.adapt(res, type: :image)
@@ -76,7 +76,7 @@ class LLM::OpenAI
     def create_variation(image:, model: "dall-e-2", response_format: "b64_json", **params)
       image = LLM.File(image)
       multi = LLM::Multipart.new(params.merge!(image:, model:, response_format:))
-      req = Net::HTTP::Post.new(path("/images/variations"), headers)
+      req = LLM::Transport::Request.post(path("/images/variations"), headers)
       req["content-type"] = multi.content_type
       transport.set_body_stream(req, multi.body)
       res, span, tracer = execute(request: req, operation: "request")
@@ -102,7 +102,7 @@ class LLM::OpenAI
     def edit(image:, prompt:, model: "dall-e-2", response_format: "b64_json", **params)
       image = LLM.File(image)
       multi = LLM::Multipart.new(params.merge!(image:, prompt:, model:, response_format:))
-      req = Net::HTTP::Post.new(path("/images/edits"), headers)
+      req = LLM::Transport::Request.post(path("/images/edits"), headers)
       req["content-type"] = multi.content_type
       transport.set_body_stream(req, multi.body)
       res, span, tracer = execute(request: req, operation: "request")

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

@@ -39,7 +39,7 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def all(**params)
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new(path("/models?#{query}"), headers)
+      req = LLM::Transport::Request.get(path("/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/openai/moderations.rb

@@ -47,7 +47,7 @@ class LLM::OpenAI
     # @param [String, LLM::Model] model The model to use
     # @return [LLM::Response]
     def create(input:, model: "omni-moderation-latest", **params)
-      req = Net::HTTP::Post.new(path("/moderations"), headers)
+      req = LLM::Transport::Request.post(path("/moderations"), headers)
       input = RequestAdapter::Moderation.new(input).adapt
       req.body = LLM.json.dump({input:, model:}.merge!(params))
       res, span, tracer = execute(request: req, operation: "request")

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

@@ -40,7 +40,7 @@ class LLM::OpenAI
       params = [params, adapt_schema(params), adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), params.delete(:stream)
       params[:stream] = true if @provider.streamable?(stream) || stream == true
-      req = Net::HTTP::Post.new(path("/responses"), headers)
+      req = LLM::Transport::Request.post(path("/responses"), headers)
       messages = build_complete_messages(prompt, params, role)
       @provider.tracer.set_request_metadata(user_input: extract_user_input(messages, fallback: prompt))
       body = LLM.json.dump({input: [adapt(messages, mode: :response)].flatten}.merge!(params))
@@ -61,7 +61,7 @@ class LLM::OpenAI
     def get(response, **params)
       response_id = response.respond_to?(:id) ? response.id : response
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new(path("/responses/#{response_id}?#{query}"), headers)
+      req = LLM::Transport::Request.get(path("/responses/#{response_id}?#{query}"), headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = ResponseAdapter.adapt(res, type: :responds)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -76,7 +76,7 @@ class LLM::OpenAI
     # @return [LLM::Object] Response body
     def delete(response)
       response_id = response.respond_to?(:id) ? response.id : response
-      req = Net::HTTP::Delete.new(path("/responses/#{response_id}"), headers)
+      req = LLM::Transport::Request.delete(path("/responses/#{response_id}"), headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
       tracer.on_request_finish(operation: "request", res:, span:)

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

@@ -31,7 +31,7 @@ class LLM::OpenAI
     # @return [LLM::Response]
     def all(**params)
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new(path("/vector_stores?#{query}"), headers)
+      req = LLM::Transport::Request.get(path("/vector_stores?#{query}"), headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = ResponseAdapter.adapt(res, type: :enumerable)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -47,7 +47,7 @@ class LLM::OpenAI
     # @return [LLM::Response]
     # @see https://platform.openai.com/docs/api-reference/vector_stores/create OpenAI docs
     def create(name:, file_ids: nil, **params)
-      req = Net::HTTP::Post.new(path("/vector_stores"), headers)
+      req = LLM::Transport::Request.post(path("/vector_stores"), headers)
       req.body = LLM.json.dump(params.merge({name:, file_ids:}).compact)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
@@ -72,7 +72,7 @@ class LLM::OpenAI
     # @see https://platform.openai.com/docs/api-reference/vector_stores/retrieve OpenAI docs
     def get(vector:)
       vector_id = vector.respond_to?(:id) ? vector.id : vector
-      req = Net::HTTP::Get.new(path("/vector_stores/#{vector_id}"), headers)
+      req = LLM::Transport::Request.get(path("/vector_stores/#{vector_id}"), headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -89,7 +89,7 @@ class LLM::OpenAI
     # @see https://platform.openai.com/docs/api-reference/vector_stores/modify OpenAI docs
     def modify(vector:, name: nil, **params)
       vector_id = vector.respond_to?(:id) ? vector.id : vector
-      req = Net::HTTP::Post.new(path("/vector_stores/#{vector_id}"), headers)
+      req = LLM::Transport::Request.post(path("/vector_stores/#{vector_id}"), headers)
       req.body = LLM.json.dump(params.merge({name:}).compact)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
@@ -105,7 +105,7 @@ class LLM::OpenAI
     # @see https://platform.openai.com/docs/api-reference/vector_stores/delete OpenAI docs
     def delete(vector:)
       vector_id = vector.respond_to?(:id) ? vector.id : vector
-      req = Net::HTTP::Delete.new(path("/vector_stores/#{vector_id}"), headers)
+      req = LLM::Transport::Request.delete(path("/vector_stores/#{vector_id}"), headers)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
       tracer.on_request_finish(operation: "request", res:, span:)
@@ -122,7 +122,7 @@ class LLM::OpenAI
     # @see https://platform.openai.com/docs/api-reference/vector_stores/search OpenAI docs
     def search(vector:, query:, **params)
       vector_id = vector.respond_to?(:id) ? vector.id : vector
-      req = Net::HTTP::Post.new(path("/vector_stores/#{vector_id}/search"), headers)
+      req = LLM::Transport::Request.post(path("/vector_stores/#{vector_id}/search"), headers)
       req.body = LLM.json.dump(params.merge({query:}).compact)
       res, span, tracer = execute(request: req, operation: "retrieval")
       res = ResponseAdapter.adapt(res, type: :enumerable)
@@ -140,7 +140,7 @@ class LLM::OpenAI
     def all_files(vector:, **params)
       vector_id = vector.respond_to?(:id) ? vector.id : vector
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new(path("/vector_stores/#{vector_id}/files?#{query}"), headers)
+      req = LLM::Transport::Request.get(path("/vector_stores/#{vector_id}/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:)
@@ -159,7 +159,7 @@ class LLM::OpenAI
     def add_file(vector:, file:, attributes: nil, **params)
       vector_id = vector.respond_to?(:id) ? vector.id : vector
       file_id = file.respond_to?(:id) ? file.id : file
-      req = Net::HTTP::Post.new(path("/vector_stores/#{vector_id}/files"), headers)
+      req = LLM::Transport::Request.post(path("/vector_stores/#{vector_id}/files"), headers)
       req.body = LLM.json.dump(params.merge({file_id:, attributes:}).compact)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
@@ -190,7 +190,7 @@ class LLM::OpenAI
     def update_file(vector:, file:, attributes:, **params)
       vector_id = vector.respond_to?(:id) ? vector.id : vector
       file_id = file.respond_to?(:id) ? file.id : file
-      req = Net::HTTP::Post.new(path("/vector_stores/#{vector_id}/files/#{file_id}"), headers)
+      req = LLM::Transport::Request.post(path("/vector_stores/#{vector_id}/files/#{file_id}"), headers)
       req.body = LLM.json.dump(params.merge({attributes:}).compact)
       res, span, tracer = execute(request: req, operation: "request")
       res = LLM::Response.new(res)
@@ -209,7 +209,7 @@ class LLM::OpenAI
       vector_id = vector.respond_to?(:id) ? vector.id : vector
       file_id = file.respond_to?(:id) ? file.id : file
       query = URI.encode_www_form(params)
-      req = Net::HTTP::Get.new(path("/vector_stores/#{vector_id}/files/#{file_id}?#{query}"), headers)
+      req = LLM::Transport::Request.get(path("/vector_stores/#{vector_id}/files/#{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:)
@@ -226,7 +226,7 @@ class LLM::OpenAI
     def delete_file(vector:, file:)
       vector_id = vector.respond_to?(:id) ? vector.id : vector
       file_id = file.respond_to?(:id) ? file.id : file
-      req = Net::HTTP::Delete.new(path("/vector_stores/#{vector_id}/files/#{file_id}"), headers)
+      req = LLM::Transport::Request.delete(path("/vector_stores/#{vector_id}/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:)

data/lib/llm/providers/openai.rb

@@ -52,7 +52,7 @@ module LLM
     # @raise (see LLM::Provider#request)
     # @return (see LLM::Provider#embed)
     def embed(input, model: "text-embedding-3-small", **params)
-      req = Net::HTTP::Post.new(path("/embeddings"), headers)
+      req = LLM::Transport::Request.post(path("/embeddings"), headers)
       req.body = LLM.json.dump({input:, model:}.merge!(params))
       res, span, tracer = execute(request: req, operation: "embeddings", model:)
       res = ResponseAdapter.adapt(res, type: :embedding)
@@ -222,7 +222,7 @@ module LLM
     def build_complete_request(prompt, params, role)
       messages = build_complete_messages(prompt, params, role)
       body = LLM.json.dump({messages: adapt(messages, mode: :complete).flatten}.merge!(params))
-      req = Net::HTTP::Post.new(completions_path, headers)
+      req = LLM::Transport::Request.post(completions_path, headers)
       transport.set_body_stream(req, StringIO.new(body))
       [req, messages]
     end

data/lib/llm/skill.rb

@@ -159,7 +159,7 @@ module LLM
       params[:concurrency] = concurrency if concurrency
       agent = Class.new(LLM::Agent) do
         instructions(instructions)
-        tools(inherit_tools ? ctx.params[:tools] : tools)
+        tools(inherit_tools ? [*ctx.params[:tools]].reject(&:skill?) : tools)
         tracer(tracer)
       end.new(ctx.llm, params)
       agent.messages.concat(messages_for(ctx))

data/lib/llm/tool.rb

@@ -202,6 +202,13 @@ class LLM::Tool
     false
   end
 
+  ##
+  # Returns true if the tool is a skill
+  # @return [Boolean]
+  def self.skill?
+    false
+  end
+
   ##
   # Returns a function bound to this tool instance.
   # @return [LLM::Function]
@@ -216,6 +223,20 @@ class LLM::Tool
     self.class.mcp?
   end
 
+  ##
+  # Returns true if the tool is an A2A tool
+  # @return [Boolean]
+  def a2a?
+    self.class.a2a?
+  end
+
+  ##
+  # Returns true if the tool is a skill
+  # @return [Boolean]
+  def skill?
+    self.class.skill?
+  end
+
   ##
   # Called when an in-flight tool run is interrupted.
   # Tools can override this to implement cooperative cleanup.

data/lib/llm/transport/curb.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+class LLM::Transport
+  ##
+  # The {LLM::Transport::Curb LLM::Transport::Curb} transport is an
+  # optional adapter for libcurl via the
+  # [curb](https://github.com/taf2/curb) gem.
+  #
+  # Curb is a C extension around libcurl. It releases the GVL during
+  # I/O so other Ruby threads can run while requests are in flight. Its
+  # timeout handling is built into libcurl itself — no thread-based
+  # timeout library required. It supports HTTP/2, connection reuse, and
+  # a wider range of network protocols out of the box.
+  #
+  # Unlike the built-in Net::HTTP transports, this transport does not
+  # require any Ruby standard library HTTP client and can be used on
+  # platforms where Net::HTTP is not available or desired.
+  #
+  # @example
+  #   LLM.openai(key: ENV["KEY"], transport: :curb)
+  #
+  # @api private
+  class Curb < self
+    INTERRUPT_ERRORS = [::IOError, ::EOFError, Errno::EBADF].freeze
+    ActiveRequest = Struct.new(:easy, keyword_init: true)
+
+    ##
+    # @param [String] host
+    # @param [Integer] port
+    # @param [Integer] timeout
+    # @param [Boolean] ssl
+    # @return [LLM::Transport::Curb]
+    def initialize(host:, port:, timeout:, ssl:)
+      @host = host
+      @port = port
+      @timeout = timeout
+      @ssl = ssl
+      @base_uri = URI("#{ssl ? "https" : "http"}://#{host}:#{port}/")
+      @monitor = Monitor.new
+    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
+
+    ##
+    # @return [Array<Class<Exception>>]
+    def interrupt_errors
+      [*INTERRUPT_ERRORS, *optional_interrupt_errors]
+    end
+
+    ##
+    # Interrupt an active request, if any.
+    #
+    # Sets the interrupt flag so the on_body callback can raise
+    # LLM::Interrupt on the next chunk.
+    #
+    # @param [Fiber] owner
+    # @return [nil]
+    def interrupt!(owner)
+      request_for(owner) or return
+      lock { (@interrupts ||= {})[owner] = true }
+    rescue *interrupt_errors
+      nil
+    end
+
+    ##
+    # Returns whether an execution owner was interrupted.
+    # @param [Fiber] owner
+    # @return [Boolean, nil]
+    def interrupted?(owner)
+      lock { @interrupts&.delete(owner) }
+    end
+
+    ##
+    # Performs a request through curb and returns a transport response
+    # wrapper so the provider layer can stay transport-agnostic.
+    #
+    # @param [LLM::Transport::Request] request
+    # @param [Fiber] owner
+    # @param [LLM::Object, nil] stream
+    # @yieldparam [LLM::Transport::Response] response
+    # @return [Object]
+    def request(request, owner:, stream: nil, &b)
+      easy = build_easy(request)
+      set_request(ActiveRequest.new(easy:), owner)
+      if stream
+        perform_streaming(easy, owner, stream)
+      elsif b
+        res = perform_blocking(easy, owner)
+        if LLM::Transport::Response === res
+          res.success? ? b.call(res) : res
+        else
+          res
+        end
+      else
+        perform_blocking(easy, owner)
+      end
+    ensure
+      clear_request(owner)
+    end
+
+    ##
+    # @return [String]
+    def inspect
+      "#<#{LLM::Utils.object_id(self)}>"
+    end
+
+    private
+
+    attr_reader :host, :port, :timeout, :ssl, :base_uri
+
+    def build_easy(request)
+      LLM.require "curb" unless defined?(::Curl)
+      easy = ::Curl::Easy.new(request_url(request))
+      easy.timeout = timeout
+      easy.connect_timeout = timeout
+      request.headers.each { |k, v| easy.headers[k] = v }
+      easy.follow_location = true
+      easy.ssl_verify_peer = false if !ssl
+      set_body(easy, request)
+      easy
+    end
+
+    def request_url(request)
+      path = request.path
+      return path if path.start_with?("http://", "https://")
+      scheme = ssl ? "https" : "http"
+      default_port = ssl ? 443 : 80
+      authority = port && port.to_i > 0 && port.to_i != default_port \
+                    ? "#{host}:#{port}" : host
+      "#{scheme}://#{authority}#{path}"
+    end
+
+    def set_body(easy, request)
+      case request.method
+      when "POST"
+        easy.post_body = request.body if request.body
+      when "PUT"
+        easy.put_data = request.body if request.body
+      when "DELETE"
+        easy.delete = true
+      end
+    end
+
+    def perform_blocking(easy, owner)
+      check_interrupted(owner)
+      easy.on_body { |chunk|
+        check_interrupted(owner)
+        chunk.bytesize
+      }
+      easy.perform
+      build_response(easy)
+    end
+
+    def perform_streaming(easy, owner, stream)
+      res = nil
+      raw_body = +""
+      decoder = stream.decoder.new(stream.parser.new(stream.streamer))
+      easy.on_body do |chunk|
+        raise LLM::Interrupt, "request interrupted" if interrupted?(owner)
+        if (res ||= build_response_from_headers(easy))&.success? \
+           && res["content-type"].to_s.include?("text/event-stream")
+          decoder << chunk
+        else
+          raw_body << chunk
+        end
+        chunk.bytesize
+      end
+      easy.perform
+      res ||= build_response(easy)
+      if raw_body.empty?
+        body = decoder.body
+        res.body = (Hash === body || Array === body) \
+                     ? LLM::Object.from(body) : body
+      else
+        res.body = raw_body
+      end
+      res
+    ensure
+      decoder&.free
+    end
+
+    def build_response(easy)
+      LLM::Transport::Response::Curb.new(
+        easy.response_code.to_i,
+        parse_headers(easy.header_str.to_s),
+        easy.body_str.to_s
+      )
+    end
+
+    def build_response_from_headers(easy)
+      return nil if easy.header_str.to_s.empty?
+      LLM::Transport::Response::Curb.new(
+        easy.response_code.to_i,
+        parse_headers(easy.header_str.to_s),
+        +""
+      )
+    end
+
+    def parse_headers(header_str)
+      headers = {}
+      header_str.each_line do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?("HTTP/")
+        key, value = line.split(/: \s*/, 2)
+        headers[key.downcase] = value if key && value
+      end
+      headers
+    end
+
+    def check_interrupted(owner)
+      raise LLM::Interrupt, "request interrupted" if interrupted?(owner)
+    end
+
+    def request_for(owner)
+      lock do
+        @requests ||= {}
+        @requests[owner]
+      end
+    end
+
+    def set_request(req, owner)
+      lock do
+        @requests ||= {}
+        @requests[owner] = req
+      end
+    end
+
+    def clear_request(owner)
+      lock { @requests&.delete(owner) }
+    end
+
+    def lock(&)
+      @monitor.synchronize(&)
+    end
+
+    def optional_interrupt_errors
+      defined?(::Async::Stop) ? [Async::Stop] : []
+    end
+  end
+end

data/lib/llm/transport/execution.rb

@@ -13,7 +13,7 @@ class LLM::Transport
 
     ##
     # Executes a HTTP request
-    # @param [Net::HTTPRequest] request
+    # @param [LLM::Transport::Request] request
     #  The request to send
     # @param [Proc] b
     #  A block to yield the response to (optional)