llm_providers 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd68399074379aa3cca94d766217abe7270698fa764b1656d1fc585977c47e49
-  data.tar.gz: 6b82fe10d4ae4bb414317c1fbbca2252976032032fcc846c2864154cb54aee62
+  metadata.gz: 11691e71acf36321f3ea66a3fec9ff250eceb606080c4b0d153af8d6ce405329
+  data.tar.gz: 64409688e08600e19b7a9cd310b8243783dfba3ae50de28483b2a0c22b0383e4
 SHA512:
-  metadata.gz: 77759c7d037da031e31db5ce76456279d5c1ed104b7df60d19289ceb6cba0ad26b7de1aa80f1e78b1afcc18b41d780ffd34718cb318b6cf905a1947adde806e0
-  data.tar.gz: 598b707ba1f7160b7b6f03b3d291a7d2bf0d726afe55d6fd86b60747c8ebc440438c5e5753597eb36016b0012552404aedc98f3cc3dc28e5ba93465c78a8b73a
+  metadata.gz: f481b19793475b67cb25ba44f05e63ecd0b16ac9527e8d2274b3e2a9b8bb21f84639e5980cb1049e10ab4146c9476c0dd53051802c12a52f50655635b96e2ecb
+  data.tar.gz: 688e43303a8b97593698091710f4f1e945278974a941e9d5f60a6e4da5262118786d6a10522a4a2f7791242958ad7b57df1a80dccdd88ed6642b0c8315040575

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.2.0] - 2026-02-27
+
+### Added
+
+- OpenRouter provider is now fully supported (no longer experimental)
+  - Custom headers: `X-Title`, `HTTP-Referer` via `app_name:` / `app_url:` options or ENV
+  - Provider routing: `provider:` option for order, fallback, data collection preferences
+  - `Openrouter.models` class method for model discovery
+  - Improved error handling with upstream provider name from OpenRouter metadata
+
+### Changed
+
+- Extracted `request_headers` method in OpenAI provider for extensibility
+- Extracted `format_stream_error` / `parse_sync_error` methods in OpenAI provider for extensibility
+
+## [0.1.1] - 2026-02-27
+
+### Fixed
+
+- Fix SSE streaming parser losing data when HTTP chunk boundaries split SSE data lines mid-line
+  - Added line buffering to `stream_response` in Anthropic, OpenAI, and OpenRouter providers
+  - Fixes tool call `input_json_delta` events being dropped, which caused tool calls with empty `{}` input
+
 ## [0.1.0] - 2026-02-13
 
 - Initial release

data/lib/llm_providers/providers/anthropic.rb

@@ -131,64 +131,19 @@ module LlmProviders
         payload[:stream] = true
         started_at = Time.now
 
+        puts "[Anthropic] stream_response payload tools: #{payload[:tools]&.size || 0}"
+        puts "[Anthropic] payload[:tools] = #{payload[:tools].inspect}" if payload[:tools]
+
         full_content = ""
         tool_calls = []
         usage = {}
+        line_buffer = ""
 
-        conn = Faraday.new do |f|
-          f.options.open_timeout = 10
-          f.options.read_timeout = 300
-          f.options.write_timeout = 30
-          f.adapter Faraday.default_adapter
-        end
-
-        response = conn.post(API_URL) do |req|
-          req.headers["Content-Type"] = "application/json"
-          req.headers["x-api-key"] = api_key
-          req.headers["anthropic-version"] = API_VERSION
-          req.body = payload.to_json
-          req.options.on_data = proc do |chunk, _|
-            process_stream_chunk(chunk, full_content, tool_calls) do |parsed|
-              if parsed[:content]
-                full_content += parsed[:content]
-                block.call(content: parsed[:content])
-              end
-              usage = parsed[:usage] if parsed[:usage]
-            end
-          end
-        end
-
-        unless response.success?
-          error_message = begin
-            if response.body.is_a?(Hash)
-              response.body["error"]&.dig("message")
-            else
-              response.body.to_s
-            end
-          rescue StandardError
-            response.body.to_s
-          end
-          raise ProviderError.new(
-            (error_message && !error_message.empty? ? error_message : nil) || "API error",
-            code: "anthropic_error"
-          )
-        end
-
-        {
-          content: full_content,
-          tool_calls: tool_calls,
-          usage: usage,
-          latency_ms: ((Time.now - started_at) * 1000).to_i,
-          raw_response: { content: full_content, tool_calls: tool_calls }
-        }
-      end
-
-      def process_stream_chunk(chunk, _full_content, tool_calls)
-        chunk.each_line do |line|
+        process_sse_line = proc do |line|
           next unless line.start_with?("data: ")
 
           data = line.sub("data: ", "").strip
-          next if data == "[DONE]"
+          next if data == "[DONE]" || data.empty?
 
           begin
             event = JSON.parse(data)
@@ -196,7 +151,11 @@ module LlmProviders
             case event["type"]
             when "content_block_delta"
               if event.dig("delta", "type") == "text_delta"
-                yield(content: event.dig("delta", "text"))
+                text = event.dig("delta", "text")
+                if text
+                  full_content += text
+                  block.call(content: text)
+                end
               elsif event.dig("delta", "type") == "input_json_delta"
                 if tool_calls.any?
                   tool_calls.last[:input_json] ||= ""
@@ -204,7 +163,9 @@ module LlmProviders
                 end
               end
             when "content_block_start"
+              puts "[Anthropic] content_block_start: #{event["content_block"]&.dig("type")}"
               if event.dig("content_block", "type") == "tool_use"
+                puts "[Anthropic] Tool use started: #{event.dig("content_block", "name")}"
                 tool_calls << {
                   id: event.dig("content_block", "id"),
                   name: event.dig("content_block", "name"),
@@ -223,17 +184,65 @@ module LlmProviders
               end
             when "message_delta"
               if event["usage"]
-                yield(usage: {
+                usage = {
                   input: event.dig("usage", "input_tokens"),
                   output: event.dig("usage", "output_tokens"),
                   cached_input: event.dig("usage", "cache_read_input_tokens")
-                })
+                }
               end
             end
           rescue JSON::ParserError
             # Skip invalid JSON
           end
         end
+
+        conn = Faraday.new do |f|
+          f.options.open_timeout = 10
+          f.options.read_timeout = 300
+          f.options.write_timeout = 30
+          f.adapter Faraday.default_adapter
+        end
+
+        response = conn.post(API_URL) do |req|
+          req.headers["Content-Type"] = "application/json"
+          req.headers["x-api-key"] = api_key
+          req.headers["anthropic-version"] = API_VERSION
+          req.body = payload.to_json
+          req.options.on_data = proc do |chunk, _|
+            line_buffer += chunk
+            lines = line_buffer.split("\n", -1)
+            line_buffer = lines.pop || ""
+
+            lines.each(&process_sse_line)
+          end
+        end
+
+        # Process any remaining data in the buffer
+        process_sse_line.call(line_buffer) unless line_buffer.empty?
+
+        unless response.success?
+          error_message = begin
+            if response.body.is_a?(Hash)
+              response.body["error"]&.dig("message")
+            else
+              response.body.to_s
+            end
+          rescue StandardError
+            response.body.to_s
+          end
+          raise ProviderError.new(
+            (error_message && !error_message.empty? ? error_message : nil) || "API error",
+            code: "anthropic_error"
+          )
+        end
+
+        {
+          content: full_content,
+          tool_calls: tool_calls,
+          usage: usage,
+          latency_ms: ((Time.now - started_at) * 1000).to_i,
+          raw_response: { content: full_content, tool_calls: tool_calls }
+        }
       end
 
       def sync_response(payload)

data/lib/llm_providers/providers/openai.rb

@@ -111,6 +111,13 @@ module LlmProviders
         end
       end
 
+      def request_headers
+        {
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{api_key}"
+        }
+      end
+
       def stream_response(payload, &block)
         payload[:stream] = true
         payload[:stream_options] = { include_usage: true }
@@ -121,6 +128,52 @@ module LlmProviders
         usage = {}
         raw_chunks = ""
         stream_error = nil
+        line_buffer = ""
+
+        process_sse_line = proc do |line|
+          next unless line.start_with?("data: ")
+
+          data = line.sub("data: ", "").strip
+          next if data == "[DONE]" || data.empty?
+
+          begin
+            event = JSON.parse(data)
+
+            if event["error"]
+              stream_error = format_stream_error(event)
+              next
+            end
+
+            if event["usage"]
+              usage = {
+                input: event.dig("usage", "prompt_tokens"),
+                output: event.dig("usage", "completion_tokens"),
+                cached_input: event.dig("usage", "prompt_tokens_details", "cached_tokens")
+              }
+            end
+
+            choice = event.dig("choices", 0)
+            next unless choice
+
+            delta = choice["delta"]
+            next unless delta
+
+            if delta["content"]
+              full_content += delta["content"]
+              block.call(content: delta["content"])
+            end
+
+            delta["tool_calls"]&.each do |tc|
+              idx = tc["index"]
+              tool_calls[idx] ||= { id: "", name: "", arguments: "" }
+              tool_calls[idx][:id] = tc["id"] if tc["id"]
+              tool_calls[idx][:name] = tc.dig("function", "name") if tc.dig("function", "name")
+              tool_calls[idx][:arguments] += tc.dig("function", "arguments").to_s
+            end
+          rescue JSON::ParserError
+            # Skip invalid JSON
+          end
+        end
 
         conn = Faraday.new do |f|
           f.options.open_timeout = 10
@@ -130,23 +183,22 @@ module LlmProviders
         end
 
         response = conn.post(self.class::API_URL) do |req|
-          req.headers["Content-Type"] = "application/json"
-          req.headers["Authorization"] = "Bearer #{api_key}"
+          request_headers.each { |k, v| req.headers[k] = v }
           req.body = payload.to_json
           req.options.on_data = proc do |chunk, _|
             raw_chunks += chunk
-            process_stream_chunk(chunk, full_content, tool_calls) do |parsed|
-              if parsed[:content]
-                full_content += parsed[:content]
-                block.call(content: parsed[:content])
-              end
-              stream_error = parsed[:error] if parsed[:error]
-              usage = parsed[:usage] if parsed[:usage]
-            end
+            line_buffer += chunk
+            lines = line_buffer.split("\n", -1)
+            line_buffer = lines.pop || ""
+
+            lines.each(&process_sse_line)
           end
         end
 
-        raise ProviderError.new(stream_error, code: "openai_error") if stream_error
+        # Process any remaining data in the buffer
+        process_sse_line.call(line_buffer) unless line_buffer.empty?
+
+        raise ProviderError.new(stream_error, code: error_code) if stream_error
 
         unless response.success?
           error_body = begin
@@ -157,7 +209,7 @@ module LlmProviders
           error_msg = error_body.dig("error", "message") || (raw_chunks.empty? ? nil : raw_chunks) || response.body.to_s
           raise ProviderError.new(
             error_msg[0, 500],
-            code: "openai_error"
+            code: error_code
           )
         end
 
@@ -174,62 +226,18 @@ module LlmProviders
         }
       end
 
-      def process_stream_chunk(chunk, _full_content, tool_calls)
-        chunk.each_line do |line|
-          next unless line.start_with?("data: ")
-
-          data = line.sub("data: ", "").strip
-          next if data == "[DONE]"
-
-          begin
-            event = JSON.parse(data)
-
-            if event["error"]
-              yield(error: event.dig("error", "message") || event["error"].to_s)
-              next
-            end
-
-            if event["usage"]
-              yield(usage: {
-                input: event.dig("usage", "prompt_tokens"),
-                output: event.dig("usage", "completion_tokens"),
-                cached_input: event.dig("usage", "prompt_tokens_details", "cached_tokens")
-              })
-            end
-
-            choice = event.dig("choices", 0)
-            next unless choice
-
-            delta = choice["delta"]
-            next unless delta
-
-            yield(content: delta["content"]) if delta["content"]
-
-            delta["tool_calls"]&.each do |tc|
-              idx = tc["index"]
-              tool_calls[idx] ||= { id: "", name: "", arguments: "" }
-              tool_calls[idx][:id] = tc["id"] if tc["id"]
-              tool_calls[idx][:name] = tc.dig("function", "name") if tc.dig("function", "name")
-              tool_calls[idx][:arguments] += tc.dig("function", "arguments").to_s
-            end
-          rescue JSON::ParserError
-            # Skip invalid JSON
-          end
-        end
-      end
-
       def sync_response(payload)
         started_at = Time.now
 
         response = http_client.post(self.class::API_URL) do |req|
-          req.headers["Authorization"] = "Bearer #{api_key}"
+          request_headers.each { |k, v| req.headers[k] = v }
           req.body = payload
         end
 
         unless response.success?
           raise ProviderError.new(
-            response.body.dig("error", "message") || "API error",
-            code: "openai_error"
+            parse_sync_error(response),
+            code: error_code
           )
         end
 
@@ -258,6 +266,18 @@ module LlmProviders
         }
       end
 
+      def error_code
+        "openai_error"
+      end
+
+      def format_stream_error(event)
+        event.dig("error", "message") || event["error"].to_s
+      end
+
+      def parse_sync_error(response)
+        response.body.dig("error", "message") || "API error"
+      end
+
       def parse_tool_input(arguments)
         return {} if arguments.nil? || arguments.empty?
 

data/lib/llm_providers/providers/openrouter.rb

@@ -2,11 +2,45 @@
 
 module LlmProviders
   module Providers
-    # Experimental: OpenRouter support is provided as-is.
-    # It wraps the OpenAI-compatible API at openrouter.ai.
-    # Not all features may work as expected with every model.
     class Openrouter < Openai
       API_URL = "https://openrouter.ai/api/v1/chat/completions"
+      MODELS_URL = "https://openrouter.ai/api/v1/models"
+
+      def self.models
+        api_key = ENV.fetch("OPENROUTER_API_KEY")
+        conn = Faraday.new do |f|
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+
+        response = conn.get(MODELS_URL) do |req|
+          req.headers["Authorization"] = "Bearer #{api_key}"
+        end
+
+        unless response.success?
+          error_msg = response.body.dig("error", "message") || "Failed to fetch models"
+          raise ProviderError.new(error_msg, code: "openrouter_error")
+        end
+
+        (response.body["data"] || []).map do |model|
+          {
+            id: model["id"],
+            name: model["name"],
+            context_length: model["context_length"],
+            pricing: {
+              prompt: model.dig("pricing", "prompt"),
+              completion: model.dig("pricing", "completion")
+            }
+          }
+        end
+      end
+
+      def initialize(app_name: nil, app_url: nil, provider: nil, **options)
+        super(**options)
+        @app_name = app_name || ENV["OPENROUTER_APP_NAME"]
+        @app_url = app_url || ENV["OPENROUTER_APP_URL"]
+        @provider_preferences = provider
+      end
 
       protected
 
@@ -17,6 +51,43 @@ module LlmProviders
       def api_key
         ENV.fetch("OPENROUTER_API_KEY")
       end
+
+      private
+
+      def build_payload(messages, system, tools)
+        payload = super
+        payload[:provider] = @provider_preferences if @provider_preferences
+        payload
+      end
+
+      def request_headers
+        headers = super
+        headers["X-Title"] = @app_name if @app_name
+        headers["HTTP-Referer"] = @app_url if @app_url
+        headers
+      end
+
+      def error_code
+        "openrouter_error"
+      end
+
+      def format_stream_error(event)
+        message = event.dig("error", "message") || event["error"].to_s
+        provider_name = event.dig("error", "metadata", "provider_name")
+        provider_name ? "[#{provider_name}] #{message}" : message
+      end
+
+      def parse_sync_error(response)
+        body = response.body
+        body = begin
+          JSON.parse(body)
+        rescue StandardError
+          {}
+        end if body.is_a?(String)
+        message = body.dig("error", "message") || "API error"
+        provider_name = body.dig("error", "metadata", "provider_name")
+        provider_name ? "[#{provider_name}] #{message}" : message
+      end
     end
   end
 end

data/lib/llm_providers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmProviders
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_providers
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - kaba