net-llm 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fd1840f770f19440379094b5b58827b6a39981a6d32a62caae2bb4e16fdd903
-  data.tar.gz: 93a759a0b3772207c355b82bd049ebf7529c75113b8ae347119814cb3c94f822
+  metadata.gz: de6c591968c95eafb5af04842bc5fc8f4f0235369a6f7010843ab9adbe2199cd
+  data.tar.gz: f8dbd38c119eacc38814a5eb173f1a2158564bce75dd5c6d111d3900e17f8136
 SHA512:
-  metadata.gz: f822a5bd79ceb1dba8bed5465e85acc747b44de49ff3c28b18894e774e2a275e81164cea5d4b7612aca25a4d9106e34e73e8b470b66fce17e684d4dd8c807117
-  data.tar.gz: 1f87089448aa9ee4b8a45bff6ce2e7a87af2fac261ca4d091ea4c2525b83b4a0282217d97b9e1df14a1adcfc8a0128e63c9da17ce2123b811a707a345bde12af
+  metadata.gz: dd8e9c389c9ed5f0614b386cf56a6359275d156197b4fe284671fc0f062d839181b938f91b898b472cf71f2d9090f5aedb9b4b725616ba97acf9f072f1a5a2a3
+  data.tar.gz: 3ac65c38e85ff03fd29e1a9dd227d674455773a35290b6871ac18d05f844afc6142a0daebcb2c88a75ec858d57b0fc7c9eddb5b07a2e4a1c10917cb6156be0bd

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.3.1] - 2025-10-08
+### Fixed
+- Added missing net-hippie runtime dependency to gemspec
+
+## [0.3.0] - 2025-10-08
+### Changed
+- Refactored all providers to use net-hippie HTTP client
+- Reduced code duplication across providers
+- Improved error handling consistency
+
+### Added
+- Added net-hippie dependency for cleaner HTTP interactions
+
 ## [0.2.0] - 2025-10-08
 
 - Add Ollama provider with streaming support

data/README.md

@@ -171,6 +171,22 @@ tools = [
 response = client.messages(messages, tools: tools)
 ```
 
+## Error Handling
+
+All non-streaming API methods return error information as a hash when requests fail:
+
+```ruby
+response = client.chat(messages, tools)
+
+if response["code"]
+  puts "Error #{response["code"]}: #{response["body"]}"
+else
+  puts response.dig('choices', 0, 'message', 'content')
+end
+```
+
+Streaming methods still raise exceptions on HTTP errors.
+
 ## API Coverage
 
 ### OpenAI

data/lib/net/llm/anthropic.rb

@@ -3,21 +3,22 @@
 module Net
   module Llm
     class Anthropic
-      attr_reader :api_key, :model
+      attr_reader :api_key, :model, :http
 
-      def initialize(api_key:, model: "claude-3-5-sonnet-20241022")
+      def initialize(api_key:, model: "claude-3-5-sonnet-20241022", http: Net::Llm.http)
         @api_key = api_key
         @model = model
+        @http = http
       end
 
       def messages(messages, system: nil, max_tokens: 1024, tools: nil, &block)
-        uri = URI("https://api.anthropic.com/v1/messages")
+        url = "https://api.anthropic.com/v1/messages"
         payload = build_payload(messages, system, max_tokens, tools, block_given?)
 
         if block_given?
-          stream_request(uri, payload, &block)
+          stream_request(url, payload, &block)
         else
-          post_request(uri, payload)
+          post_request(url, payload)
         end
       end
 
@@ -35,51 +36,41 @@ module Net
         payload
       end
 
-      def post_request(uri, payload)
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = true
+      def headers
+        {
+          "x-api-key" => api_key,
+          "anthropic-version" => "2023-06-01"
+        }
+      end
 
-        request = Net::HTTP::Post.new(uri)
-        request["x-api-key"] = api_key
-        request["anthropic-version"] = "2023-06-01"
-        request["Content-Type"] = "application/json"
-        request.body = payload.to_json
+      def post_request(url, payload)
+        handle_response(http.post(url, headers: headers, body: payload))
+      end
 
-        response = http.start { |h| h.request(request) }
-        raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body)
+      def handle_response(response)
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        else
+          { "code" => response.code, "body" => response.body }
+        end
       end
 
-      def stream_request(uri, payload, &block)
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = true
-        http.read_timeout = 3600
-
-        request = Net::HTTP::Post.new(uri)
-        request["x-api-key"] = api_key
-        request["anthropic-version"] = "2023-06-01"
-        request["Content-Type"] = "application/json"
-        request.body = payload.to_json
-
-        http.start do |h|
-          h.request(request) do |response|
-            unless response.is_a?(Net::HTTPSuccess)
-              raise "HTTP #{response.code}: #{response.body}"
-            end
+      def stream_request(url, payload, &block)
+        http.post(url, headers: headers, body: payload) do |response|
+          raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
 
-            buffer = ""
-            response.read_body do |chunk|
-              buffer += chunk
+          buffer = ""
+          response.read_body do |chunk|
+            buffer += chunk
 
-              while (event = extract_sse_event(buffer))
-                next if event[:data].nil? || event[:data].empty?
-                next if event[:data] == "[DONE]"
+            while (event = extract_sse_event(buffer))
+              next if event[:data].nil? || event[:data].empty?
+              next if event[:data] == "[DONE]"
 
-                json = JSON.parse(event[:data])
-                block.call(json)
+              json = JSON.parse(event[:data])
+              block.call(json)
 
-                break if json["type"] == "message_stop"
-              end
+              break if json["type"] == "message_stop"
             end
           end
         end

data/lib/net/llm/ollama.rb

@@ -3,111 +3,89 @@
 module Net
   module Llm
     class Ollama
-      attr_reader :host, :model
+      attr_reader :host, :model, :http
 
-      def initialize(host: "localhost:11434", model: "llama2")
+      def initialize(host: "localhost:11434", model: "llama2", http: Net::Llm.http)
         @host = host
         @model = model
+        @http = http
       end
 
       def chat(messages, &block)
-        uri = build_uri("/api/chat")
+        url = build_url("/api/chat")
         payload = { model: model, messages: messages, stream: block_given? }
 
         if block_given?
-          stream_request(uri, payload, &block)
+          stream_request(url, payload, &block)
         else
-          post_request(uri, payload)
+          post_request(url, payload)
         end
       end
 
       def generate(prompt, &block)
-        uri = build_uri("/api/generate")
+        url = build_url("/api/generate")
         payload = { model: model, prompt: prompt, stream: block_given? }
 
         if block_given?
-          stream_request(uri, payload, &block)
+          stream_request(url, payload, &block)
         else
-          post_request(uri, payload)
+          post_request(url, payload)
         end
       end
 
       def embeddings(input)
-        uri = build_uri("/api/embed")
+        url = build_url("/api/embed")
         payload = { model: model, input: input }
-        post_request(uri, payload)
+        post_request(url, payload)
       end
 
       def tags
-        uri = build_uri("/api/tags")
-        get_request(uri)
+        url = build_url("/api/tags")
+        response = http.get(url)
+        handle_response(response)
       end
 
       def show(name)
-        uri = build_uri("/api/show")
+        url = build_url("/api/show")
         payload = { name: name }
-        post_request(uri, payload)
+        post_request(url, payload)
       end
 
       private
 
-      def build_uri(path)
+      def build_url(path)
         base = host.start_with?("http://", "https://") ? host : "http://#{host}"
-        URI("#{base}#{path}")
+        "#{base}#{path}"
       end
 
-      def get_request(uri)
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = uri.scheme == "https"
-        request = Net::HTTP::Get.new(uri)
-        request["Accept"] = "application/json"
-
-        response = http.start { |h| h.request(request) }
-        raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body)
+      def post_request(url, payload)
+        response = http.post(url, body: payload)
+        handle_response(response)
       end
 
-      def post_request(uri, payload)
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = uri.scheme == "https"
-        request = Net::HTTP::Post.new(uri)
-        request["Accept"] = "application/json"
-        request["Content-Type"] = "application/json"
-        request.body = payload.to_json
-
-        response = http.start { |h| h.request(request) }
-        raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body)
+      def handle_response(response)
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        else
+          { "code" => response.code, "body" => response.body }
+        end
       end
 
-      def stream_request(uri, payload, &block)
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = uri.scheme == "https"
-        http.read_timeout = 3600
-
-        request = Net::HTTP::Post.new(uri)
-        request["Accept"] = "application/json"
-        request["Content-Type"] = "application/json"
-        request.body = payload.to_json
-
-        http.start do |h|
-          h.request(request) do |response|
-            unless response.is_a?(Net::HTTPSuccess)
-              raise "HTTP #{response.code}: #{response.body}"
-            end
+      def stream_request(url, payload, &block)
+        http.post(url, body: payload) do |response|
+          raise "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
 
-            buffer = ""
-            response.read_body do |chunk|
-              buffer += chunk
+          buffer = ""
+          response.read_body do |chunk|
+            buffer += chunk
 
-              while (message = extract_message(buffer))
-                next if message.empty?
+            while (message = extract_message(buffer))
+              next if message.empty?
 
-                json = JSON.parse(message)
-                block.call(json)
+              json = JSON.parse(message)
+              block.call(json)
 
-                break if json["done"]
-              end
+              break if json["done"]
             end
           end
         end

data/lib/net/llm/openai.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Net
+  module Llm
+    class OpenAI
+      attr_reader :api_key, :base_url, :model, :http
+
+      def initialize(api_key:, base_url: "https://api.openai.com/v1", model: "gpt-4o-mini", http: Net::Llm.http)
+        @api_key = api_key
+        @base_url = base_url
+        @model = model
+        @http = http
+      end
+
+      def chat(messages, tools)
+        handle_response(http.post(
+          "#{base_url}/chat/completions",
+          headers: headers,
+          body: { model: model, messages: messages, tools: tools, tool_choice: "auto" }
+        ))
+      end
+
+      def models
+        handle_response(http.get("#{base_url}/models", headers: headers))
+      end
+
+      def embeddings(input, model: "text-embedding-ada-002")
+        handle_response(http.post(
+          "#{base_url}/embeddings",
+          headers: headers,
+          body: { model: model, input: input },
+        ))
+      end
+
+      private
+
+      def headers
+        { "Authorization" => Net::Hippie.bearer_auth(api_key) }
+      end
+
+      def handle_response(response)
+        if response.is_a?(Net::HTTPSuccess)
+          JSON.parse(response.body)
+        else
+          { "code" => response.code, "body" => response.body }
+        end
+      end
+    end
+  end
+end

data/lib/net/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Net
   module Llm
-    VERSION = "0.2.0"
+    VERSION = "0.3.1"
   end
 end

data/lib/net/llm.rb

@@ -1,76 +1,21 @@
 # frozen_string_literal: true
 
 require_relative "llm/version"
+require_relative "llm/openai"
 require_relative "llm/ollama"
 require_relative "llm/anthropic"
-require "net/http"
+require "net/hippie"
 require "json"
-require "uri"
 
 module Net
   module Llm
     class Error < StandardError; end
-    DEFAULT_TIMEOUT = 60 * 2
 
-    class OpenAI
-      attr_reader :api_key, :base_url, :model
-
-      def initialize(api_key:, base_url: "https://api.openai.com/v1", model: "gpt-4o-mini")
-        @api_key = api_key
-        @base_url = base_url
-        @model = model
-      end
-
-      def chat(messages, tools, timeout: DEFAULT_TIMEOUT)
-        uri = URI("#{base_url}/chat/completions")
-        request = Net::HTTP::Post.new(uri)
-        request["Authorization"] = "Bearer #{api_key}"
-        request["Content-Type"] = "application/json"
-        request.body = { model: model, messages: messages, tools: tools, tool_choice: "auto" }.to_json
-
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = true
-        http.open_timeout = timeout
-        http.read_timeout = timeout
-        http.write_timeout = timeout if http.respond_to?(:write_timeout=)
-
-        response = http.start { |h| h.request(request) }
-        raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body)
-      end
-
-      def models(timeout: DEFAULT_TIMEOUT)
-        uri = URI("#{base_url}/models")
-        request = Net::HTTP::Get.new(uri)
-        request["Authorization"] = "Bearer #{api_key}"
-
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = true
-        http.open_timeout = timeout
-        http.read_timeout = timeout
-
-        response = http.start { |h| h.request(request) }
-        raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body)
-      end
-
-      def embeddings(input, model: "text-embedding-ada-002", timeout: DEFAULT_TIMEOUT)
-        uri = URI("#{base_url}/embeddings")
-        request = Net::HTTP::Post.new(uri)
-        request["Authorization"] = "Bearer #{api_key}"
-        request["Content-Type"] = "application/json"
-        request.body = { model: model, input: input }.to_json
-
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        http.use_ssl = true
-        http.open_timeout = timeout
-        http.read_timeout = timeout
-        http.write_timeout = timeout if http.respond_to?(:write_timeout=)
-
-        response = http.start { |h| h.request(request) }
-        raise "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
-        JSON.parse(response.body)
-      end
+    def self.http
+      @http ||= Net::Hippie::Client.new(
+        read_timeout: 3600,
+        open_timeout: 10
+      )
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: net-llm
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - mo khan
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: uri
+  name: net-hippie
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -38,19 +38,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: net-http
+  name: uri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '1.0'
 description: A minimal Ruby gem providing interfaces to connect to OpenAI, Ollama,
   and Anthropic (Claude) LLM APIs
 email:
@@ -66,6 +66,7 @@ files:
 - lib/net/llm.rb
 - lib/net/llm/anthropic.rb
 - lib/net/llm/ollama.rb
+- lib/net/llm/openai.rb
 - lib/net/llm/version.rb
 - sig/net/llm.rbs
 homepage: https://github.com/xlgmokha/net-llm