durable-llm 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e531cd0c24bb1c3d7a2c5490b3d268694827c08d831955219d5fa32884b1a51
-  data.tar.gz: dd4bedf9b3a9a09addef7306fe51bcad5082a75163d0d383eff449df5c1ebf54
+  metadata.gz: 41b81b7592103ed34098a473f004036c0a9ed22a6f43cd764c32d057ac840cd9
+  data.tar.gz: 0caf0d378409b4d025261049c41deb769b111eb556a77843495202cc58cea430
 SHA512:
-  metadata.gz: d5bf3a883a62807f86b578169eda22074a8d30e8b7005f9177dd16b04a2be26af5625e26b5b963f6ece166b81c8082d18da2fb9851a03edec3e2388ce2443dce
-  data.tar.gz: 03d93aeb004df8d6bf0cfbf945734565d7e5b4d7fe4b98a5b3f4b2a622202b7f907d51730cbcbf37ec9dbed9c0098844c7272ff6a6a00be7c3aeea9e19531607
+  metadata.gz: 395a3c6e8b542107c01122c983beb0d43918a3d5567137c9652a716ddd01d89b7d8399e3e00f7059fde2bca82e80141063bf1dc15602bb9c665304aa4a393505
+  data.tar.gz: af5ea2f180fdbac3cd52a6f856f37b419b1568f93c03aad36df0906ab79c336b5091372c4b048dcc4307e0984d8ed66f72cc1b047fd295ca9174e1f2c784bdf2

data/CONFIGURE.md

@@ -0,0 +1,132 @@
+# Configuring Durable-LLM
+
+## Introduction
+
+Durable-LLM supports multiple LLM providers and can be configured using environment variables or a configuration block. This document outlines the various configuration options available.
+
+## General Configuration
+
+You can configure Durable-LLM using a configuration block:
+
+```ruby
+Durable::Llm.configure do |config|
+  # Configuration options go here
+end
+```
+
+## Provider-specific Configuration
+
+### OpenAI
+
+To configure the OpenAI provider, you can set the following environment variables:
+
+- `OPENAI_API_KEY`: Your OpenAI API key
+- `OPENAI_ORGANIZATION`: (Optional) Your OpenAI organization ID
+
+Alternatively, you can configure it in the configuration block:
+
+```ruby
+Durable::Llm.configure do |config|
+  config.openai.api_key = 'your-api-key'
+  config.openai.organization = 'your-organization-id' # Optional
+end
+```
+
+### Anthropic
+
+To configure the Anthropic provider, you can set the following environment variable:
+
+- `ANTHROPIC_API_KEY`: Your Anthropic API key
+
+Alternatively, you can configure it in the configuration block:
+
+```ruby
+Durable::Llm.configure do |config|
+  config.anthropic.api_key = 'your-api-key'
+end
+```
+
+### Hugging Face
+
+To configure the Hugging Face provider, you can set the following environment variable:
+
+- `HUGGINGFACE_API_KEY`: Your Hugging Face API key
+
+Alternatively, you can configure it in the configuration block:
+
+```ruby
+Durable::Llm.configure do |config|
+  config.huggingface.api_key = 'your-api-key'
+end
+```
+
+### Groq
+
+To configure the Groq provider, you can set the following environment variable:
+
+- `GROQ_API_KEY`: Your Groq API key
+
+Alternatively, you can configure it in the configuration block:
+
+```ruby
+Durable::Llm.configure do |config|
+  config.groq.api_key = 'your-api-key'
+end
+```
+
+## Using Environment Variables
+
+You can also use environment variables configure any provider. The format is:
+
+```
+DLLM__PROVIDER__SETTING
+```
+
+For example:
+
+```
+DLLM__OPENAI__API_KEY=your-openai-api-key
+DLLM__ANTHROPIC__API_KEY=your-anthropic-api-key
+```
+
+## Loading Configuration from Datasette
+
+Durable-LLM can load configuration from a io.datasette.llm configuration file located at `~/.config/io.datasette.llm/keys.json`. If this file exists, it will be parsed and used to set API keys for the supported providers.
+
+## Default Provider
+
+You can set a default provider in the configuration:
+
+```ruby
+Durable::Llm.configure do |config|
+  config.default_provider = 'openai'
+end
+```
+
+The default provider is set to 'openai' if not specified.
+
+## Supported Models
+
+Each provider supports a set of models. You can get the list of supported models for a provider using the `models` method:
+
+```ruby
+Durable::Llm::Providers::OpenAI.models
+Durable::Llm::Providers::Anthropic.models
+Durable::Llm::Providers::Huggingface.models
+Durable::Llm::Providers::Groq.models
+```
+
+Note that some services (Anthropic, for example) don't offer a models endpoint, so they are hardcoded; others (Huggingface) have a inordinately long list, so also have a hardcoded list, at least for now.
+
+## Streaming Support
+
+Some providers support streaming responses. You can check if a provider supports streaming:
+
+```ruby
+Durable::Llm::Providers::OpenAI.stream?
+```
+
+## Conclusion
+
+By properly configuring Durable-LLM, you can easily switch between different LLM providers and models in your application. Remember to keep your API keys secure and never commit them to version control.
+

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    durable-llm (0.1.2)
+    durable-llm (0.1.3)
       event_stream_parser (~> 1.0)
       faraday (> 1.0)
       highline (~> 3.1)

data/lib/durable/llm/cli.rb

@@ -10,29 +10,26 @@ module Durable
         true
       end
 
-      desc "prompt PROMPT", "Run a prompt"
-      option :model, aliases: "-m", desc: "Specify the model to use"
-      option :system, aliases: "-s", desc: "Set a system prompt"
-      option :continue, aliases: "-c", type: :boolean, desc: "Continue the previous conversation"
-      option :conversation, aliases: "--cid", desc: "Continue a specific conversation by ID"
-      option :no_stream, type: :boolean, desc: "Disable streaming of tokens"
-      option :option, aliases: "-o", type: :hash, desc: "Set model-specific options"
-
-      def prompt(prompt)
-        config = Durable::Llm.configuration
-        model = options[:model] || "gpt-3.5-turbo"
+      desc 'prompt PROMPT', 'Run a prompt'
+      option :model, aliases: '-m', desc: 'Specify the model to use'
+      option :system, aliases: '-s', desc: 'Set a system prompt'
+      option :continue, aliases: '-c', type: :boolean, desc: 'Continue the previous conversation'
+      option :conversation, aliases: '--cid', desc: 'Continue a specific conversation by ID'
+      option :no_stream, type: :boolean, desc: 'Disable streaming of tokens'
+      option :option, aliases: '-o', type: :hash, desc: 'Set model-specific options'
+
+      def prompt(*prompt)
+        model = options[:model] || 'gpt-3.5-turbo'
         provider_class = Durable::Llm::Providers.model_id_to_provider(model)
 
-        if provider_class.nil? 
-          raise "no provider found for model '#{model}'"
-        end
+        raise "no provider found for model '#{model}'" if provider_class.nil?
 
         provider_name = provider_class.name.split('::').last.downcase.to_sym
         client = Durable::Llm::Client.new(provider_name)
-        
+
         messages = []
-        messages << { role: "system", content: options[:system] } if options[:system]
-        messages << { role: "user", content: prompt }
+        messages << { role: 'system', content: options[:system] } if options[:system]
+        messages << { role: 'user', content: prompt.join(' ') }
 
         params = {
           model: model,
@@ -40,37 +37,34 @@ module Durable
         }
         params.merge!(options[:option]) if options[:option]
 
-        if options[:no_stream] 
+        if options[:no_stream] || !client.stream?
           response = client.completion(params)
-          puts response.choices.first.to_s
+          puts response.choices.first
         else
           client.stream(params) do |chunk|
-            print chunk.to_s
+            print chunk
             $stdout.flush
           end
         end
       end
 
-      desc "chat", "Start an interactive chat"
-      option :model, aliases: "-m", desc: "Specify the model to use"
-      option :system, aliases: "-s", desc: "Set a system prompt"
-      option :continue, aliases: "-c", type: :boolean, desc: "Continue the previous conversation"
-      option :conversation, aliases: "--cid", desc: "Continue a specific conversation by ID"
-      option :option, aliases: "-o", type: :hash, desc: "Set model-specific options"
+      desc 'chat', 'Start an interactive chat'
+      option :model, aliases: '-m', desc: 'Specify the model to use'
+      option :system, aliases: '-s', desc: 'Set a system prompt'
+      option :continue, aliases: '-c', type: :boolean, desc: 'Continue the previous conversation'
+      option :conversation, aliases: '--cid', desc: 'Continue a specific conversation by ID'
+      option :option, aliases: '-o', type: :hash, desc: 'Set model-specific options'
       def chat
-        config = Durable::Llm.configuration
-        model = options[:model] || "gpt-3.5-turbo"
+        model = options[:model] || 'gpt-3.5-turbo'
         provider_class = Durable::Llm::Providers.model_id_to_provider(model)
 
-        if provider_class.nil? || provider_class.name.nil?
-          raise "no provider found for model '#{model}'"
-        end
+        raise "no provider found for model '#{model}'" if provider_class.nil? || provider_class.name.nil?
 
         provider_name = provider_class.name.split('::').last.downcase.to_sym
         client = Durable::Llm::Client.new(provider_name)
-        
+
         messages = []
-        messages << { role: "system", content: options[:system] } if options[:system]
+        messages << { role: 'system', content: options[:system] } if options[:system]
 
         cli = HighLine.new
 
@@ -79,16 +73,16 @@ module Durable
         cli.say("Type '!multi' to enter multiple lines, then '!end' to finish")
 
         loop do
-          input = cli.ask("> ")
-          break if ['exit', 'quit'].include?(input.downcase)
+          input = cli.ask('> ')
+          break if %w[exit quit].include?(input.downcase)
 
-          if input == "!multi"
+          if input == '!multi'
             input = cli.ask("Enter multiple lines. Type '!end' to finish:") do |q|
-              q.gather = "!end"
+              q.gather = '!end'
             end
           end
 
-          messages << { role: "user", content: input }
+          messages << { role: 'user', content: input }
           params = {
             model: model,
             messages: messages
@@ -97,20 +91,20 @@ module Durable
 
           response = client.completion(params)
           cli.say(response.choices.first.to_s)
-          messages << { role: "assistant", content: response.choices.first.to_s }
+          messages << { role: 'assistant', content: response.choices.first.to_s }
         end
       end
 
-      desc "models", "List available models"
-      option :options, type: :boolean, desc: "Show model options"
+      desc 'models', 'List available models'
+      option :options, type: :boolean, desc: 'Show model options'
       def models
         cli = HighLine.new
-        cli.say("Available models:")
-        
+        cli.say('Available models:')
+
         Durable::Llm::Providers.providers.each do |provider_name|
           provider_class = Durable::Llm::Providers.const_get(provider_name.to_s.capitalize)
-          provider_models = provider_class.new.models
-          
+          provider_models = provider_class.models
+
           cli.say("#{provider_name.to_s.capitalize}:")
           provider_models.each do |model|
             cli.say("  #{model}")

data/lib/durable/llm/client.rb

@@ -8,10 +8,7 @@ module Durable
       attr_accessor :model
 
       def initialize(provider_name, options = {})
-
-        if options['model'] || options[:model]
-          @model = options.delete('model') || options.delete(:model)
-        end
+        @model = options.delete('model') || options.delete(:model) if options['model'] || options[:model]
 
         provider_class = Durable::Llm::Providers.const_get(provider_name.to_s.capitalize)
 
@@ -21,12 +18,13 @@ module Durable
       def default_params
         { model: @model }
       end
-      def quick_complete(text, opts = {})
 
-        response = completion(process_params(messages:[{role: 'user', content: text}]))
+      def quick_complete(text, _opts = {})
+        response = completion(process_params(messages: [{ role: 'user', content: text }]))
 
         response.choices.first.message.content
       end
+
       def completion(params = {})
         @provider.completion(process_params(params))
       end
@@ -43,6 +41,10 @@ module Durable
         @provider.stream(process_params(params), &block)
       end
 
+      def stream?
+        @provider.stream?
+      end
+
       private
 
       def process_params(opts = {})

data/lib/durable/llm/configuration.rb

@@ -10,44 +10,42 @@ module Durable
         @providers = {}
         @default_provider = 'openai'
         load_from_env
+      end
 
+      def clear
+        @providers.clear
+        @default_provider = 'openai'
       end
 
       def load_from_datasette
-
         config_file = File.expand_path('~/.config/io.datasette.llm/keys.json')
 
         if File.exist?(config_file)
           config_data = JSON.parse(File.read(config_file))
 
           Durable::Llm::Providers.providers.each do |provider|
-
             @providers[provider.to_sym] ||= OpenStruct.new
 
-            if config_data[provider.to_s]
-              @providers[provider.to_sym][:api_key] = config_data[provider.to_s]
-            end
-
+            @providers[provider.to_sym][:api_key] = config_data[provider.to_s] if config_data[provider.to_s]
           end
         end
-
       rescue JSON::ParserError => e
         puts "Error parsing JSON file: #{e.message}"
       end
 
       def load_from_env
         ENV.each do |key, value|
-          if key.start_with?('DLLM__')
-            parts = key.split('__')
-            provider = parts[1].downcase.to_sym
-            setting = parts[2].downcase.to_sym
-            @providers[provider] ||= OpenStruct.new
-            @providers[provider][setting] = value
-          end
+          next unless key.start_with?('DLLM__')
+
+          parts = key.split('__')
+          provider = parts[1].downcase.to_sym
+          setting = parts[2].downcase.to_sym
+          @providers[provider] ||= OpenStruct.new
+          @providers[provider][setting] = value
         end
       end
 
-      def method_missing(method_name, *args, &block)
+      def method_missing(method_name, *args)
         if method_name.to_s.end_with?('=')
           provider = method_name.to_s.chomp('=').to_sym
           @providers[provider] = args.first

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

@@ -1,4 +1,3 @@
-
 require 'faraday'
 require 'json'
 require 'durable/llm/errors'
@@ -27,7 +26,7 @@ module Durable
         end
 
         def completion(options)
-          options['max_tokens'] ||=1024
+          options['max_tokens'] ||= 1024
           response = @conn.post('/v1/messages') do |req|
             req.headers['x-api-key'] = @api_key
             req.headers['anthropic-version'] = '2023-06-01'
@@ -40,6 +39,7 @@ module Durable
         def models
           self.class.models
         end
+
         def self.models
           ['claude-3-5-sonnet-20240620', 'claude-3-opus-20240229', 'claude-3-haiku-20240307']
         end
@@ -47,15 +47,17 @@ module Durable
         def self.stream?
           true
         end
-        def stream(options, &block)
+
+        def stream(options)
           options[:stream] = true
           response = @conn.post('/v1/messages') 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|
+            req.options.on_data = proc do |chunk, _size, _total|
               next if chunk.strip.empty?
+
               yield AnthropicStreamResponse.new(chunk) if chunk.start_with?('data: ')
             end
           end
@@ -66,20 +68,20 @@ module Durable
         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
+          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
@@ -114,8 +116,8 @@ module Durable
           attr_reader :role, :content
 
           def initialize(content)
-            @role = [content].flatten.map { |_| _['type']}.join(' ')
-            @content = [content].flatten.map { |_| _['text']}.join(' ')
+            @role = [content].flatten.map { |_| _['type'] }.join(' ')
+            @content = [content].flatten.map { |_| _['text'] }.join(' ')
           end
 
           def to_s
@@ -127,7 +129,7 @@ module Durable
           attr_reader :choices
 
           def initialize(fragment)
-            parsed = JSON.parse(fragment.split("data: ").last)
+            parsed = JSON.parse(fragment.split('data: ').last)
             @choices = [AnthropicStreamChoice.new(parsed['delta'])]
           end
 

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

@@ -3,7 +3,7 @@ module Durable
     module Providers
       class Base
         def default_api_key
-          raise NotImplementedError, "Subclasses must implement default_api_key"
+          raise NotImplementedError, 'Subclasses must implement default_api_key'
         end
 
         attr_accessor :api_key
@@ -12,37 +12,52 @@ module Durable
           @api_key = api_key || default_api_key
         end
 
-
         def completion(options)
-          raise NotImplementedError, "Subclasses must implement completion"
+          raise NotImplementedError, 'Subclasses must implement completion'
         end
 
-        def self.models 
-          []
+        def self.models
+          cache_dir = File.expand_path("#{Dir.home}/.local/durable-llm/cache")
+
+          FileUtils.mkdir_p(cache_dir) unless File.directory?(cache_dir)
+          cache_file = File.join(cache_dir, "#{name.split('::').last}.json")
+
+          file_exists = File.exist?(cache_file)
+          file_new_enough = file_exists && File.mtime(cache_file) > Time.now - 3600
+
+          if file_exists && file_new_enough
+            JSON.parse(File.read(cache_file))
+          else
+            models = new.models
+            File.write(cache_file, JSON.generate(models)) if models.length > 0
+            models
+          end
         end
+
         def models
-          raise NotImplementedError, "Subclasses must implement 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"
+          raise NotImplementedError, 'Subclasses must implement stream'
         end
 
         def embedding(model:, input:, **options)
-          raise NotImplementedError, "Subclasses must implement embedding"
+          raise NotImplementedError, 'Subclasses must implement embedding'
         end
 
         private
 
         def handle_response(response)
-          raise NotImplementedError, "Subclasses must implement handle_response"
+          raise NotImplementedError, 'Subclasses must implement handle_response'
         end
       end
     end

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

@@ -0,0 +1,100 @@
+require 'faraday'
+require 'json'
+require 'durable/llm/errors'
+require 'durable/llm/providers/base'
+
+module Durable
+  module Llm
+    module Providers
+      class Cohere < Durable::Llm::Providers::Base
+        BASE_URL = 'https://api.cohere.ai/v2'
+
+        def default_api_key
+          Durable::Llm.configuration.cohere&.api_key || ENV['COHERE_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('chat') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.headers['Content-Type'] = 'application/json'
+            req.body = options
+          end
+
+          handle_response(response)
+        end
+
+        def models
+          response = @conn.get('models') do |req|
+            req.headers['Authorization'] = "Bearer #{@api_key}"
+            req.headers['OpenAI-Organization'] = @organization if @organization
+          end
+
+          data = handle_response(response).raw_response
+          data['models']&.map { |model| model['name'] }
+        end
+
+        def self.stream?
+          false
+        end
+
+        private
+
+        def handle_response(response)
+          case response.status
+          when 200..299
+            CohereResponse.new(response.body)
+          when 401
+            raise Durable::Llm::AuthenticationError, response.body['message']
+          when 429
+            raise Durable::Llm::RateLimitError, response.body['message']
+          when 400..499
+            raise Durable::Llm::InvalidRequestError, response.body['message']
+          when 500..599
+            raise Durable::Llm::ServerError, response.body['message']
+          else
+            raise Durable::Llm::APIError, "Unexpected response code: #{response.status}"
+          end
+        end
+
+        class CohereResponse
+          attr_reader :raw_response
+
+          def initialize(response)
+            @raw_response = response
+          end
+
+          def choices
+            [@raw_response.dig('message', 'content')].flatten.map { |generation| CohereChoice.new(generation) }
+          end
+
+          def to_s
+            choices.map(&:to_s).join(' ')
+          end
+        end
+
+        class CohereChoice
+          attr_reader :text
+
+          def initialize(generation)
+            @text = generation['text']
+          end
+
+          def to_s
+            @text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -22,6 +22,7 @@ module Durable
             faraday.adapter Faraday.default_adapter
           end
         end
+
         def conn
           self.class.conn
         end
@@ -49,8 +50,6 @@ module Durable
         end
 
         def models
-
-
           response = conn.get('models') do |req|
             req.headers['Authorization'] = "Bearer #{@api_key}"
           end
@@ -59,9 +58,6 @@ module Durable
 
           resp['data'].map { |model| model['id'] }
         end
-        def self.models
-          Groq.new.models
-        end
 
         def self.stream?
           false
@@ -100,6 +96,7 @@ module Durable
           def to_s
             choices.map(&:to_s).join(' ')
           end
+
           def to_h
             @raw_response.dup
           end
@@ -135,7 +132,7 @@ module Durable
           attr_reader :choices
 
           def initialize(fragment)
-            json_frag = fragment.split("data: ").last.strip
+            json_frag = fragment.split('data: ').last.strip
             puts json_frag
             parsed = JSON.parse(json_frag)
             @choices = parsed['choices'].map { |choice| GroqStreamChoice.new(choice) }

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

@@ -37,8 +37,9 @@ module Durable
         def models
           self.class.models
         end
+
         def self.models
-          ['gpt2', 'bert-base-uncased', 'distilbert-base-uncased'] # could use expansion
+          %w[gpt2 bert-base-uncased distilbert-base-uncased] # could use expansion
         end
 
         private

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

@@ -55,39 +55,27 @@ module Durable
           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)
-
+        def stream(options)
           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'
 
-            if options['temperature']
-              options['temperature'] = options['temperature'].to_f
-            end
+            options['temperature'] = options['temperature'].to_f if options['temperature']
 
             req.body = options
 
-            user_proc = Proc.new do |chunk, size, total|
-
-
+            user_proc = proc do |chunk, _size, _total|
               yield OpenAIStreamResponse.new(chunk)
-
             end
 
-            req.options.on_data = to_json_stream( user_proc: user_proc )
-
+            req.options.on_data = to_json_stream(user_proc: user_proc)
           end
 
           handle_response(response)
@@ -113,7 +101,7 @@ module Durable
             end
 
             parser.feed(chunk) do |_type, data|
-              user_proc.call(JSON.parse(data)) unless data == "[DONE]"
+              user_proc.call(JSON.parse(data)) unless data == '[DONE]'
             end
           end
         end
@@ -125,8 +113,8 @@ module Durable
         end
 
         # END-CODE-FROM
-        
-        def handle_response(response, responseClass=OpenAIResponse)
+
+        def handle_response(response, responseClass = OpenAIResponse)
           case response.status
           when 200..299
             responseClass.new(response.body)
@@ -144,7 +132,11 @@ module Durable
         end
 
         def parse_error_message(response)
-          body = JSON.parse(response.body) rescue nil
+          body = begin
+            JSON.parse(response.body)
+          rescue StandardError
+            nil
+          end
           message = body&.dig('error', 'message') || response.body
           "#{response.status} Error: #{message}"
         end
@@ -203,8 +195,7 @@ module Durable
           attr_reader :choices
 
           def initialize(parsed)
-
-            @choices =  OpenAIStreamChoice.new(parsed['choices'])
+            @choices = OpenAIStreamChoice.new(parsed['choices'])
           end
 
           def to_s

data/lib/durable/llm/providers.rb

@@ -9,15 +9,13 @@ module Durable
       end
 
       def self.providers
+        @provider_list ||= constants.select do |const_name|
+          const = const_get(const_name)
+          last_component = const.name.split('::').last
+          next if last_component == 'Base'
 
-        @provider_list ||= begin
-                             constants.select do |const_name|
-                               const = const_get(const_name)
-                               last_component = const.name.split('::').last
-                               next if last_component == 'Base'
-                               const.is_a?(Class) && const.to_s.split('::').last.to_s == const_name.to_s
-                             end.map(&:to_s).map(&:downcase).map(&:to_sym)
-                           end
+          const.is_a?(Class) && const.to_s.split('::').last.to_s == const_name.to_s
+        end.map(&:to_s).map(&:downcase).map(&:to_sym)
       end
 
       def self.model_ids

data/lib/durable/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Durable
   module Llm
-    VERSION = "0.1.3"
+    VERSION = '0.1.4'
   end
 end

data/lib/durable/llm.rb

@@ -1,8 +1,8 @@
-require "zeitwerk"
+require 'zeitwerk'
 loader = Zeitwerk::Loader.new
-loader.tag = File.basename(__FILE__, ".rb")
+loader.tag = File.basename(__FILE__, '.rb')
 loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
-loader.push_dir(File.dirname(__FILE__) + '/..' )
+loader.push_dir(File.dirname(__FILE__) + '/..')
 
 require 'durable/llm/configuration'
 
@@ -10,6 +10,7 @@ module Durable
   module Llm
     class << self
       attr_accessor :configuration
+
       def config
         configuration
       end
@@ -24,4 +25,3 @@ end
 
 Durable::Llm.configure do
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable-llm
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Durable Programming Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-10-09 00:00:00.000000000 Z
+date: 2024-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -174,6 +174,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - CLI.md
+- CONFIGURE.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -192,6 +193,7 @@ files:
 - lib/durable/llm/providers.rb
 - lib/durable/llm/providers/anthropic.rb
 - lib/durable/llm/providers/base.rb
+- lib/durable/llm/providers/cohere.rb
 - lib/durable/llm/providers/groq.rb
 - lib/durable/llm/providers/huggingface.rb
 - lib/durable/llm/providers/openai.rb