durable-llm 0.1.0

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

@@ -0,0 +1,164 @@
+
+require 'faraday'
+require 'json'
+require 'durable/llm/errors'
+require 'durable/llm/providers/base'
+
+module Durable
+  module Llm
+    module Providers
+      class Anthropic < Durable::Llm::Providers::Base
+        BASE_URL = 'https://api.anthropic.com'
+
+        def default_api_key
+          Durable::Llm.configuration.anthropic&.api_key || ENV['ANTHROPIC_API_KEY']
+        end
+
+        attr_accessor :api_key
+
+        def initialize(api_key: nil)
+          @api_key = api_key || default_api_key
+          @conn = Faraday.new(url: BASE_URL) do |faraday|
+            faraday.request :json
+            faraday.response :json
+            faraday.adapter Faraday.default_adapter
+          end
+        end
+
+        def completion(options)
+          response = @conn.post('/v1/chat/completions') do |req|
+            req.headers['x-api-key'] = @api_key
+            req.headers['anthropic-version'] = '2023-06-01'
+            req.body = options
+          end
+
+          handle_response(response)
+        end
+
+        def models
+          self.class.models
+        end
+        def self.models
+          ['claude-3-opus', 'claude-3-sonnet', 'claude-3-haiku', 'claude-2.1', 'claude-2.0', 'claude-instant-1.2']
+        end
+
+        def self.stream?
+          true
+        end
+        def stream(options, &block)
+          options[:stream] = true
+          response = @conn.post('/v1/chat/completions') do |req|
+            req.headers['x-api-key'] = @api_key
+            req.headers['anthropic-version'] = '2023-06-01'
+            req.headers['Accept'] = 'text/event-stream'
+            req.body = options
+            req.options.on_data = Proc.new do |chunk, size, total|
+              next if chunk.strip.empty?
+              yield AnthropicStreamResponse.new(chunk) if chunk.start_with?('data: ')
+            end
+          end
+
+          handle_response(response)
+        end
+
+        private
+
+        def handle_response(response)
+              case response.status
+              when 200..299
+                AnthropicResponse.new(response.body)
+              when 401
+                raise Durable::Llm::AuthenticationError, response.body.dig('error', 'message')
+              when 429
+                raise Durable::Llm::RateLimitError, response.body.dig('error', 'message')
+              when 400..499
+                raise Durable::Llm::InvalidRequestError, response.body.dig('error', 'message')
+              when 500..599
+                raise Durable::Llm::ServerError, response.body.dig('error', 'message')
+              else
+                raise Durable::Llm::APIError, "Unexpected response code: #{response.status}"
+              end
+        end
+
+        class AnthropicResponse
+          attr_reader :raw_response
+
+          def initialize(response)
+            @raw_response = response
+          end
+
+          def choices
+            [@raw_response['content']].map { |content| AnthropicChoice.new(content) }
+          end
+
+          def to_s
+            choices.map(&:to_s).join(' ')
+          end
+        end
+
+        class AnthropicChoice
+          attr_reader :message
+
+          def initialize(content)
+            @message = AnthropicMessage.new(content)
+          end
+
+          def to_s
+            @message.to_s
+          end
+        end
+
+        class AnthropicMessage
+          attr_reader :role, :content
+
+          def initialize(content)
+            @role = [content].flatten.map { |_| _['type']}.join(' ')
+            @content = [content].flatten.map { |_| _['text']}.join(' ')
+          end
+
+          def to_s
+            @content
+          end
+        end
+
+        class AnthropicStreamResponse
+          attr_reader :choices
+
+          def initialize(fragment)
+            parsed = JSON.parse(fragment.split("data: ").last)
+            @choices = [AnthropicStreamChoice.new(parsed['delta'])]
+          end
+
+          def to_s
+            @choices.map(&:to_s).join(' ')
+          end
+        end
+
+        class AnthropicStreamChoice
+          attr_reader :delta
+
+          def initialize(delta)
+            @delta = AnthropicStreamDelta.new(delta)
+          end
+
+          def to_s
+            @delta.to_s
+          end
+        end
+
+        class AnthropicStreamDelta
+          attr_reader :type, :text
+
+          def initialize(delta)
+            @type = delta['type']
+            @text = delta['text']
+          end
+
+          def to_s
+            @text || ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable/llm/providers/base.rb

@@ -0,0 +1,49 @@
+module Durable
+  module Llm
+    module Providers
+      class Base
+        def default_api_key
+          raise NotImplementedError, "Subclasses must implement default_api_key"
+        end
+
+        attr_accessor :api_key
+
+        def initialize(api_key: nil)
+          @api_key = api_key || default_api_key
+        end
+
+        def completion(options)
+          raise NotImplementedError, "Subclasses must implement completion"
+        end
+
+        def self.models 
+          []
+        end
+        def models
+          raise NotImplementedError, "Subclasses must implement models"
+        end
+
+        def self.stream?
+          false
+        end
+        def stream?
+          self.class.stream?
+        end
+
+        def stream(options, &block)
+          raise NotImplementedError, "Subclasses must implement stream"
+        end
+
+        def embedding(model:, input:, **options)
+          raise NotImplementedError, "Subclasses must implement embedding"
+        end
+
+        private
+
+        def handle_response(response)
+          raise NotImplementedError, "Subclasses must implement handle_response"
+        end
+      end
+    end
+  end
+end

data/lib/durable/llm/providers/groq.rb

@@ -0,0 +1,177 @@
+require 'faraday'
+require 'json'
+require 'durable/llm/errors'
+require 'durable/llm/providers/base'
+
+module Durable
+  module Llm
+    module Providers
+      class Groq < Durable::Llm::Providers::Base
+        BASE_URL = 'https://api.groq.com/openai/v1'
+
+        def default_api_key
+          Durable::Llm.configuration.groq&.api_key || ENV['GROQ_API_KEY']
+        end
+
+        attr_accessor :api_key
+
+        def self.conn
+          Faraday.new(url: BASE_URL) do |faraday|
+            faraday.request :json
+            faraday.response :json
+            faraday.adapter Faraday.default_adapter
+          end
+        end
+        def conn
+          self.class.conn
+        end
+
+        def initialize(api_key: nil)
+          @api_key = api_key || default_api_key
+        end
+
+        def completion(options)
+          response = conn.post('chat/completions') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.body = options
+          end
+
+          handle_response(response)
+        end
+
+        def embedding(model:, input:, **options)
+          response = conn.post('embeddings') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.body = { model: model, input: input, **options }
+          end
+
+          handle_response(response)
+        end
+
+        def models
+
+
+          response = conn.get('models') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+          end
+
+          resp = handle_response(response).to_h
+
+          resp['data'].map { |model| model['id'] }
+        end
+        def self.models
+          Groq.new.models
+        end
+
+        def self.stream?
+          false
+        end
+
+        private
+
+        def handle_response(response)
+          case response.status
+          when 200..299
+            GroqResponse.new(response.body)
+          when 401
+            raise Durable::Llm::AuthenticationError, response.body['error']['message']
+          when 429
+            raise Durable::Llm::RateLimitError, response.body['error']['message']
+          when 400..499
+            raise Durable::Llm::InvalidRequestError, response.body['error']['message']
+          when 500..599
+            raise Durable::Llm::ServerError, response.body['error']['message']
+          else
+            raise Durable::Llm::APIError, "Unexpected response code: #{response.status}"
+          end
+        end
+
+        class GroqResponse
+          attr_reader :raw_response
+
+          def initialize(response)
+            @raw_response = response
+          end
+
+          def choices
+            @raw_response['choices'].map { |choice| GroqChoice.new(choice) }
+          end
+
+          def to_s
+            choices.map(&:to_s).join(' ')
+          end
+          def to_h
+            @raw_response.dup
+          end
+        end
+
+        class GroqChoice
+          attr_reader :message, :finish_reason
+
+          def initialize(choice)
+            @message = GroqMessage.new(choice['message'])
+            @finish_reason = choice['finish_reason']
+          end
+
+          def to_s
+            @message.to_s
+          end
+        end
+
+        class GroqMessage
+          attr_reader :role, :content
+
+          def initialize(message)
+            @role = message['role']
+            @content = message['content']
+          end
+
+          def to_s
+            @content
+          end
+        end
+
+        class GroqStreamResponse
+          attr_reader :choices
+
+          def initialize(fragment)
+            json_frag = fragment.split("data: ").last.strip
+            puts json_frag
+            parsed = JSON.parse(json_frag)
+            @choices = parsed['choices'].map { |choice| GroqStreamChoice.new(choice) }
+          end
+
+          def to_s
+            @choices.map(&:to_s).join(' ')
+          end
+        end
+
+        class GroqStreamChoice
+          attr_reader :delta, :finish_reason
+
+          def initialize(choice)
+            @delta = GroqStreamDelta.new(choice['delta'])
+            @finish_reason = choice['finish_reason']
+          end
+
+          def to_s
+            @delta.to_s
+          end
+        end
+
+        class GroqStreamDelta
+          attr_reader :role, :content
+
+          def initialize(delta)
+            @role = delta['role']
+            @content = delta['content']
+          end
+
+          def to_s
+            @content || ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable/llm/providers/huggingface.rb

@@ -0,0 +1,93 @@
+require 'faraday'
+require 'json'
+require 'durable/llm/errors'
+require 'durable/llm/providers/base'
+
+module Durable
+  module Llm
+    module Providers
+      class Huggingface < Durable::Llm::Providers::Base
+        BASE_URL = 'https://api-inference.huggingface.co/models'
+
+        def default_api_key
+          Durable::Llm.configuration.huggingface&.api_key || ENV['HUGGINGFACE_API_KEY']
+        end
+
+        attr_accessor :api_key
+
+        def initialize(api_key: nil)
+          @api_key = api_key || default_api_key
+          @conn = Faraday.new(url: BASE_URL) do |faraday|
+            faraday.request :json
+            faraday.response :json
+            faraday.adapter Faraday.default_adapter
+          end
+        end
+
+        def completion(options)
+          model = options.delete(:model) || 'gpt2'
+          response = @conn.post("/#{model}") do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.body = options
+          end
+
+          handle_response(response)
+        end
+
+        def models
+          self.class.models
+        end
+        def self.models
+          ['gpt2', 'bert-base-uncased', 'distilbert-base-uncased'] # could use expansion
+        end
+
+        private
+
+        def handle_response(response)
+          case response.status
+          when 200..299
+            HuggingfaceResponse.new(response.body)
+          when 401
+            raise Durable::Llm::AuthenticationError, response.body['error']
+          when 429
+            raise Durable::Llm::RateLimitError, response.body['error']
+          when 400..499
+            raise Durable::Llm::InvalidRequestError, response.body['error']
+          when 500..599
+            raise Durable::Llm::ServerError, response.body['error']
+          else
+            raise Durable::Llm::APIError, "Unexpected response code: #{response.status}"
+          end
+        end
+
+        class HuggingfaceResponse
+          attr_reader :raw_response
+
+          def initialize(response)
+            @raw_response = response
+          end
+
+          def choices
+            [@raw_response.first].map { |choice| HuggingfaceChoice.new(choice) }
+          end
+
+          def to_s
+            choices.map(&:to_s).join(' ')
+          end
+        end
+
+        class HuggingfaceChoice
+          attr_reader :text
+
+          def initialize(choice)
+            @text = choice['generated_text']
+          end
+
+          def to_s
+            @text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+require 'faraday'
+require 'json'
+require 'durable/llm/errors'
+require 'durable/llm/providers/base'
+
+module Durable
+  module Llm
+    module Providers
+      class OpenAI < Durable::Llm::Providers::Base
+        BASE_URL = 'https://api.openai.com/v1'
+
+        def default_api_key
+          Durable::Llm.configuration.openai&.api_key || ENV['OPENAI_API_KEY']
+        end
+
+        attr_accessor :api_key, :organization
+
+        def initialize(api_key: nil, organization: nil)
+          @api_key = api_key || default_api_key
+          @organization = organization || ENV['OPENAI_ORGANIZATION']
+          @conn = Faraday.new(url: BASE_URL) do |faraday|
+            faraday.request :json
+            faraday.response :json
+            faraday.adapter Faraday.default_adapter
+          end
+        end
+
+        def completion(options)
+          response = @conn.post('chat/completions') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.headers['OpenAI-Organization'] = @organization if @organization
+            req.body = options
+          end
+
+          handle_response(response)
+        end
+
+        def embedding(model:, input:, **options)
+          response = @conn.post('embeddings') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.headers['OpenAI-Organization'] = @organization if @organization
+            req.body = { model: model, input: input, **options }
+          end
+
+          handle_response(response, OpenAIEmbeddingResponse)
+        end
+
+        def models
+          response = @conn.get('models') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.headers['OpenAI-Organization'] = @organization if @organization
+          end
+
+          handle_response(response).data.map { |model| model['id'] }
+        end
+
+        def self.models
+          self.new.models 
+        end
+
+        def self.stream?
+          true
+        end
+
+        def stream(options, &block)
+          options[:stream] = true
+          response = @conn.post('chat/completions') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.headers['OpenAI-Organization'] = @organization if @organization
+            req.headers['Accept'] = 'text/event-stream'
+            req.body = options
+            req.options.on_data = Proc.new do |chunk, size, total|
+              next if chunk.strip.empty?
+
+              yield OpenAIStreamResponse.new(chunk)
+            end
+          end
+
+          handle_response(response)
+        end
+
+        private
+
+        def handle_response(response, responseClass=OpenAIResponse)
+          case response.status
+          when 200..299
+            responseClass.new(response.body)
+          when 401
+            raise Durable::Llm::AuthenticationError, parse_error_message(response)
+          when 429
+            raise Durable::Llm::RateLimitError, parse_error_message(response)
+          when 400..499
+            raise Durable::Llm::InvalidRequestError, parse_error_message(response)
+          when 500..599
+            raise Durable::Llm::ServerError, parse_error_message(response)
+          else
+            raise Durable::Llm::APIError, "Unexpected response code: #{response.status}"
+          end
+        end
+
+        def parse_error_message(response)
+          body = JSON.parse(response.body) rescue nil
+          message = body&.dig('error', 'message') || response.body
+          "#{response.status} Error: #{message}"
+        end
+
+        class OpenAIResponse
+          attr_reader :raw_response
+
+          def initialize(response)
+            @raw_response = response
+          end
+
+          def choices
+            @raw_response['choices'].map { |choice| OpenAIChoice.new(choice) }
+          end
+
+          def data
+            @raw_response['data']
+          end
+
+          def embedding
+            @raw_response['embedding']
+          end
+
+          def to_s
+            choices.map(&:to_s).join(' ')
+          end
+        end
+
+        class OpenAIChoice
+          attr_reader :message, :finish_reason
+
+          def initialize(choice)
+            @message = OpenAIMessage.new(choice['message'])
+            @finish_reason = choice['finish_reason']
+          end
+
+          def to_s
+            @message.to_s
+          end
+        end
+
+        class OpenAIMessage
+          attr_reader :role, :content
+
+          def initialize(message)
+            @role = message['role']
+            @content = message['content']
+          end
+
+          def to_s
+            @content
+          end
+        end
+
+        class OpenAIStreamResponse
+          attr_reader :choices
+
+          def initialize(fragment)
+            parsed = fragment.split("\n").map { |_|  JSON.parse(_) }
+
+            @choices = parsed.map { |_| OpenAIStreamChoice.new(_['choices'])}
+          end
+
+          def to_s
+            @choices.map(&:to_s).join('')
+          end
+        end
+
+        class OpenAIEmbeddingResponse
+          attr_reader :embedding
+
+          def initialize(data)
+            @embedding = data.dig('data', 0, 'embedding')
+          end
+
+          def to_a
+            @embedding
+          end
+        end
+
+        class OpenAIStreamChoice
+          attr_reader :delta, :finish_reason
+
+          def initialize(choice)
+            @choice = [choice].flatten.first
+            @delta = OpenAIStreamDelta.new(@choice['delta'])
+            @finish_reason = @choice['finish_reason']
+          end
+
+          def to_s
+            @delta.to_s
+          end
+        end
+
+        class OpenAIStreamDelta
+          attr_reader :role, :content
+
+          def initialize(delta)
+            @role = delta['role']
+            @content = delta['content']
+          end
+
+          def to_s
+            @content || ''
+          end
+        end
+      end
+    end
+  end
+end