durable-llm 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29574965602c24158dda8d571f97a8587e42eb50ef0248063cdc57a3ef909e84
-  data.tar.gz: 3ec88df34382fe52b4df9e2f0ee726a7999b160bdb07fc291445146d5b92629f
+  metadata.gz: 16b4fd786241b183bdc060199d2623155b5082570e687b839ecb3d1b610e25ab
+  data.tar.gz: c8257d7a7a8a3b0847a21b9b574cc405e6cb2f5b81690f2de59949c0a4a4c69e
 SHA512:
-  metadata.gz: 5efe187dd42f3149fe6e1571f9d22299eba2493fd0d747f6a7743a856b4a2c7b16c9a8490189fbcb7ee6d45eebc5aa1406997e189234fbf29b3c595ef12fb132
-  data.tar.gz: 6c99719b35db2cfafb7844aa42a90eaace7f16a976821ca86831026b98d01b490214446c52079da31622bdaf4d517d9e702030f2a6b881f9e86d3b750ae37255
+  metadata.gz: 563537cf042a171267c80edd1fee12965822a7b766acbe39e71cc2ba146b5291773f28dd04f31d35f35565f0b3f149cc5b40b724cfac1a6f24c8f78fef6a9c85
+  data.tar.gz: 521c0c54ac096d6e8df667777ba61ac941bd2e5bbc9bba001b5eed3065db97958cceb4bae57ae4bfd834eb04ecc85e176bd793ce20e62c41d0ed7131e7a30734

data/CLI.md

@@ -0,0 +1,107 @@
+Here's the content for the file CLI.md:
+
+# Durable-LLM Command Line Interface (CLI)
+
+Durable-LLM provides a command-line interface (CLI) for interacting with various Large Language Model providers. This document outlines the available commands and their usage.
+
+## Installation
+
+Ensure you have installed the Durable-LLM gem:
+
+```
+gem install durable-llm
+```
+
+## Commands
+
+### prompt
+
+Run a single prompt and get a response.
+
+```
+dllm prompt [OPTIONS] PROMPT
+```
+
+Options:
+- `-m, --model MODEL`: Specify the model to use (default: gpt-3.5-turbo)
+- `-s, --system SYSTEM_PROMPT`: Set a system prompt
+- `-c, --continue`: Continue the previous conversation
+- `--cid CONVERSATION_ID`: Continue a specific conversation by ID
+- `--no-stream`: Disable streaming of tokens
+- `-o, --option KEY:VALUE`: Set model-specific options
+
+Example:
+```
+dllm prompt -m gpt-4 "What is the capital of France?"
+```
+
+### chat
+
+Start an interactive chat session.
+
+```
+dllm chat [OPTIONS]
+```
+
+Options:
+- `-m, --model MODEL`: Specify the model to use (default: gpt-3.5-turbo)
+- `-s, --system SYSTEM_PROMPT`: Set a system prompt
+- `-c, --continue`: Continue the previous conversation
+- `--cid CONVERSATION_ID`: Continue a specific conversation by ID
+- `-o, --option KEY:VALUE`: Set model-specific options
+
+Example:
+```
+dllm chat -m claude-3-opus-20240229
+```
+
+### models
+
+List available models.
+
+```
+dllm models [OPTIONS]
+```
+
+Options:
+- `--options`: Show model options
+
+Example:
+```
+dllm models
+```
+
+## Configuration
+
+The CLI uses the same configuration as the Durable-LLM library. You can set up your API keys and other settings using environment variables or a configuration file.
+
+Environment variables:
+- `DLLM__OPENAI__API_KEY`: OpenAI API key
+- `DLLM__ANTHROPIC__API_KEY`: Anthropic API key
+- (Add other provider API keys as needed)
+
+Alternatively, you can use the configuration file located at `~/.config/io.datasette.llm/keys.json` for compatibility with the `llm` tool.
+
+## Examples
+
+1. Run a simple prompt:
+   ```
+   dllm prompt "Tell me a joke"
+   ```
+
+2. Start an interactive chat with a specific model:
+   ```
+   dllm chat -m gpt-4
+   ```
+
+3. List available models:
+   ```
+   dllm models
+   ```
+
+4. Run a prompt with a system message and custom options:
+   ```
+   dllm prompt -s "You are a helpful assistant" -o temperature:0.7 "Explain quantum computing"
+   ```
+
+Remember to set up your API keys before using the CLI. Enjoy using Durable-LLM from the command line!

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    durable-llm (0.1.0)
-      faraday (~> 2.0)
+    durable-llm (0.1.1)
+      event_stream_parser (~> 1.0)
+      faraday (> 1.0)
       highline (~> 3.1)
       json (~> 2.6)
       thor (~> 1.3)

data/LICENSE.txt

@@ -1,6 +1,11 @@
+All code outside of the enterprise/ directory is under the following license unless 
+otherwise specified.
+
+---
+
 The MIT License (MIT)
 
-Copyright (c) 2024 Durable Programming Team
+Copyright (c) 2024 Durable Programming, LLC.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,3 +24,31 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
+
+
+---
+
+Contains code from ruby-openai project. The following license information is from the ruby-openai repo and applies to the code so denoted:
+
+The MIT License (MIT)
+
+Copyright (c) 2020 Alex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -87,6 +87,8 @@ end
 
 Thank you to the lite-llm and llm.datasette.io projects for their hard work, which was invaluable to this project. The dllm command line tool is patterned after the llm tool, though not as full-featured (yet).
 
+The streaming jsonl code is from the ruby-openai repo; many thanks for their hard work.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/durableprogramming/durable-llm.

data/examples/anthropic.md

@@ -0,0 +1,85 @@
+Here's the content for the file examples/anthropic.md with a line-by-line explanation of the script:
+
+# Anthropic Example
+
+This example demonstrates how to use the Durable-LLM gem with Anthropic's API.
+
+## Basic Usage
+
+```ruby
+# Import the Durable-LLM library
+require 'durable/llm'
+
+# Initialize the client with the Anthropic provider
+# You can pass the API key directly or set it in the environment variable ANTHROPIC_API_KEY
+client = Durable::Llm::Client.new(:anthropic, api_key: 'your-api-key')
+
+# Make a completion request
+response = client.completion(
+  # Specify the Anthropic model to use
+  model: 'claude-3-5-sonnet-20240620',
+  # Provide the messages for the conversation
+  messages: [
+    { role: 'user', content: 'What is the capital of France?' }
+  ],
+  # Set the maximum number of tokens for the response (optional). Defaults to 1024.
+  max_tokens: 100
+)
+
+# Print the response content
+puts response.choices.first.message.content
+
+# Output: Paris is the capital of France.
+```
+
+## Streaming
+
+```ruby
+# Use the stream method for real-time responses
+client.stream(
+  model: 'claude-3-5-sonnet-20240620',
+  messages: [
+    { role: 'user', content: 'Tell me a short story about a robot.' }
+  ],
+  max_tokens: 200
+) do |chunk|
+  # Print each chunk of the response as it's received
+  print chunk.to_s
+end
+
+# Output will be printed as it's received from the API
+```
+
+## Configuration
+
+You can configure the Anthropic provider globally:
+
+```ruby
+# Set up global configuration for the Anthropic provider
+Durable::Llm.configure do |config|
+  config.anthropic.api_key = 'your-api-key'
+end
+
+# Create a client using the global configuration
+client = Durable::Llm::Client.new(:anthropic)
+```
+
+## Error Handling
+
+```ruby
+begin
+  # Attempt to make a completion request
+  response = client.completion(
+    model: 'claude-3-5-sonnet-20240620',
+    messages: [{ role: 'user', content: 'Hello!' }]
+  )
+rescue Durable::Llm::RateLimitError => e
+  # Handle rate limit errors
+  puts "Rate limit exceeded: #{e.message}"
+rescue Durable::Llm::APIError => e
+  # Handle general API errors
+  puts "API error occurred: #{e.message}"
+end
+```
+
+This example covers basic usage, streaming, configuration, and error handling for the Anthropic provider using the Durable-LLM gem. Note that Anthropic's API doesn't support embeddings, so that functionality is not included in this example.

data/examples/openai.md

@@ -0,0 +1,85 @@
+# OpenAI Example
+
+This example demonstrates how to use the Durable-LLM gem with OpenAI's API.
+
+## Basic Usage
+
+```ruby
+require 'durable/llm'
+
+# Initialize the client
+client = Durable::Llm::Client.new(:openai, api_key: 'your-api-key')
+
+# Make a completion request
+response = client.completion(
+  model: 'gpt-3.5-turbo',
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'What is the capital of France?' }
+  ]
+)
+
+puts response.choices.first.message.content
+
+# Output: Paris is the capital of France.
+```
+
+## Streaming
+
+```ruby
+client.stream(
+  model: 'gpt-3.5-turbo',
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'Tell me a short story about a robot.' }
+  ]
+) do |chunk|
+  print chunk.to_s
+end
+
+# Output will be printed as it's received from the API
+```
+
+## Embeddings
+
+```ruby
+embedding_response = client.embed(
+  model: 'text-embedding-ada-002',
+  input: 'The quick brown fox jumps over the lazy dog'
+)
+
+puts embedding_response.embedding.first(5).inspect
+
+# Output: [0.0023064255, -0.009327292, -0.0028842434, 0.022165427, -0.01085841]
+```
+
+## Configuration
+
+You can configure the OpenAI provider globally:
+
+```ruby
+Durable::Llm.configure do |config|
+  config.openai.api_key = 'your-api-key'
+  config.openai.organization = 'your-organization-id' # Optional
+end
+
+# Now you can create a client without specifying the API key
+client = Durable::Llm::Client.new(:openai)
+```
+
+## Error Handling
+
+```ruby
+begin
+  response = client.completion(
+    model: 'gpt-3.5-turbo',
+    messages: [{ role: 'user', content: 'Hello!' }]
+  )
+rescue Durable::Llm::RateLimitError => e
+  puts "Rate limit exceeded: #{e.message}"
+rescue Durable::Llm::APIError => e
+  puts "API error occurred: #{e.message}"
+end
+```
+
+This example covers basic usage, streaming, embeddings, configuration, and error handling for the OpenAI provider using the Durable-LLM gem.

data/lib/durable/llm/configuration.rb

@@ -8,6 +8,7 @@ module Durable
 
       def initialize
         @providers = {}
+        @default_provider = 'openai'
         load_from_env
 
       end

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

@@ -18,6 +18,7 @@ module Durable
 
         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
@@ -26,7 +27,8 @@ module Durable
         end
 
         def completion(options)
-          response = @conn.post('/v1/chat/completions') do |req|
+          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'
             req.body = options
@@ -39,7 +41,7 @@ module Durable
           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']
+          ['claude-3-5-sonnet-20240620', 'claude-3-opus-20240229', 'claude-3-haiku-20240307']
         end
 
         def self.stream?
@@ -47,7 +49,7 @@ module Durable
         end
         def stream(options, &block)
           options[:stream] = true
-          response = @conn.post('/v1/chat/completions') do |req|
+          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'

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

@@ -2,6 +2,7 @@ require 'faraday'
 require 'json'
 require 'durable/llm/errors'
 require 'durable/llm/providers/base'
+require 'event_stream_parser'
 
 module Durable
   module Llm
@@ -63,17 +64,30 @@ module Durable
         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'
+
+            if options['temperature']
+              options['temperature'] = options['temperature'].to_f
+            end
+
             req.body = options
-            req.options.on_data = Proc.new do |chunk, size, total|
-              next if chunk.strip.empty?
+
+            user_proc = Proc.new do |chunk, size, total|
+
 
               yield OpenAIStreamResponse.new(chunk)
+
             end
+
+            req.options.on_data = to_json_stream( user_proc: user_proc )
+
           end
 
           handle_response(response)
@@ -81,6 +95,37 @@ module Durable
 
         private
 
+        # CODE-FROM: ruby-openai @ https://github.com/alexrudall/ruby-openai/blob/main/lib/openai/http.rb
+        # MIT License: https://github.com/alexrudall/ruby-openai/blob/main/LICENSE.md
+        # Given a proc, returns an outer proc that can be used to iterate over a JSON stream of chunks.
+        # For each chunk, the inner user_proc is called giving it the JSON object. The JSON object could
+        # be a data object or an error object as described in the OpenAI API documentation.
+        #
+        # @param user_proc [Proc] The inner proc to call for each JSON object in the chunk.
+        # @return [Proc] An outer proc that iterates over a raw stream, converting it to JSON.
+        def to_json_stream(user_proc:)
+          parser = EventStreamParser::Parser.new
+
+          proc do |chunk, _bytes, env|
+            if env && env.status != 200
+              raise_error = Faraday::Response::RaiseError.new
+              raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
+            end
+
+            parser.feed(chunk) do |_type, data|
+              user_proc.call(JSON.parse(data)) unless data == "[DONE]"
+            end
+          end
+        end
+
+        def try_parse_json(maybe_json)
+          JSON.parse(maybe_json)
+        rescue JSON::ParserError
+          maybe_json
+        end
+
+        # END-CODE-FROM
+        
         def handle_response(response, responseClass=OpenAIResponse)
           case response.status
           when 200..299
@@ -157,14 +202,13 @@ module Durable
         class OpenAIStreamResponse
           attr_reader :choices
 
-          def initialize(fragment)
-            parsed = fragment.split("\n").map { |_|  JSON.parse(_) }
+          def initialize(parsed)
 
-            @choices = parsed.map { |_| OpenAIStreamChoice.new(_['choices'])}
+            @choices =  OpenAIStreamChoice.new(parsed['choices'])
           end
 
           def to_s
-            @choices.map(&:to_s).join('')
+            @choices.to_s
           end
         end
 

data/lib/durable/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Durable
   module Llm
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   end
 end

data/lib/durable/llm.rb

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

data/lib/durable.rb

@@ -0,0 +1,7 @@
+require 'durable/llm'
+
+module Durable
+  # This module serves as a namespace for the Durable gem.
+  # It currently only requires the Llm module, but can be expanded
+  # in the future to include other Durable-related functionality.
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: durable-llm
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Durable Programming Team
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: event_stream_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -159,12 +173,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- CLI.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - enterprise/GET_ENTERPRISE.md
+- examples/anthropic.md
+- examples/openai.md
+- lib/durable.rb
 - lib/durable/llm.rb
 - lib/durable/llm/cli.rb
 - lib/durable/llm/client.rb