gen-ai 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa99531962c9b41b65e33716910d7debc1b847283dcc89a0047d03819f73b016
-  data.tar.gz: 86803a58994aca6fa3428674def207f318423ea28d04942a7427d6f2ae883a61
+  metadata.gz: fe2c9cb2e87385fea4fb417b62fbfeaaf4c825367395bb2b06b1deeddf3defec
+  data.tar.gz: 8c452c2767c8c2ae5a166b26329ba23b7190efa71f19a5d055e66110d2511cde
 SHA512:
-  metadata.gz: 151cbe9615dfb96bd9fecd96fc87d122c1f13368c1a236180432256336d4c22680c8d1fbc654e53a347b8c9391a99a3e1faef76e5051f1524a0ac28e7129caca
-  data.tar.gz: d8ae8a92ef41e0e09af567aecaed6d33ed0af6ac80af6cbbe092269b90e974674aa53626eff449ef642657c5cb9c9e7b88bc076339e234b60eeaaf13a9fba356
+  metadata.gz: 953848790eb404df5294ff6e629643d6735ca6c2506b0129d667f12b89e56a3c5b838fa1cd9bb7257f779c8c5e047ed667702c533d75b301625dcc53434a7632
+  data.tar.gz: 3f6c563be51280f1d539ab72ad65b3f5732180423ae86c726fd91e4111103043a9812fca91cd242bebabdf7839640af8a3878b6d97538e4c797b39bf3733e7ff

data/.rubocop.yml

@@ -32,7 +32,9 @@ Layout/ArgumentAlignment:
 Layout/LineLength:
   Exclude:
     - spec/**/*.rb
+    - gen-ai.gemspec
 
 Metrics/BlockLength:
   Exclude:
     - spec/**/*.rb
+    - gen-ai.gemspec

data/gen-ai.gemspec

@@ -38,8 +38,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'faraday-multipart', '~> 1.0'
   spec.add_dependency 'zeitwerk', '~> 2.6'
 
+  spec.add_development_dependency 'gemini-ai', '~> 3.2'
   spec.add_development_dependency 'google_palm_api', '~> 0.1'
-  spec.add_development_dependency 'ruby-openai', '~> 5.1'
+  spec.add_development_dependency 'ruby-openai', '~> 6.0'
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html
   spec.metadata['rubygems_mfa_required'] = 'true'

data/lib/gen_ai/api/format/gemini.rb

@@ -20,11 +20,28 @@ module GenAI
         end
 
         def extract_completions(response)
-          response['candidates'].map { |candidate| candidate.dig('content', 'parts', 0, 'text') }
+          if response.is_a?(Array)
+            response.map { |completion| extract_candidates(completion) }
+          else
+            extract_candidates(response)
+          end
+        end
+
+        def chunk_params_from_streaming(chunk)
+          {
+            model: 'gemini-pro',
+            index: chunk.dig('candidates', 0, 'index'),
+            value: chunk.dig('candidates', 0, 'content', 'parts', 0, 'text'),
+            raw: chunk
+          }
         end
 
         private
 
+        def extract_candidates(candidates)
+          candidates['candidates'].map { |candidate| candidate.dig('content', 'parts', 0, 'text') }
+        end
+
         def role_for(message)
           message[:role] == 'user' ? USER_ROLE : ASSISTANT_ROLE
         end

data/lib/gen_ai/api/format/open_ai.rb

@@ -11,6 +11,31 @@ module GenAI
         def extract_completions(response)
           response['choices'].map { |choice| choice.dig('message', 'content') }
         end
+
+        def chunk_params_from_streaming(chunk)
+          {
+            model: chunk['model'],
+            index: chunk.dig('choices', 0, 'index'),
+            value: chunk.dig('choices', 0, 'delta', 'content'),
+            raw: chunk
+          }
+        end
+
+        def build_raw_response(chunks)
+          { 'choices' => build_raw_choices(chunks),
+            'usage' => { 'completion_tokens' => chunks.values.map(&:size).sum } }
+        end
+
+        def build_raw_choices(chunks)
+          chunks.map do |key, values|
+            {
+              'index' => key,
+              'logprobs' => nil,
+              'finish_reason' => 'stop',
+              'message' => { 'role' => 'asssistant', 'content' => values.map(&:value).join }
+            }
+          end
+        end
       end
     end
   end

data/lib/gen_ai/base.rb

@@ -15,6 +15,8 @@ module GenAI
       raise GenAI::ApiError, "#{api_provider_name} API error: #{response.dig('error', 'message')}" if response['error']
 
       response
+    rescue Faraday::BadRequestError => e
+      raise GenAI::ApiError, "#{api_provider_name} API error: #{e.response[:body].dig('error', 'message')}"
     end
 
     def provider_name
@@ -28,5 +30,9 @@ module GenAI
     def build_result(model:, raw:, parsed:)
       GenAI::Result.new(provider: provider_name.to_sym, model: model, raw: raw, values: parsed)
     end
+
+    def build_chunk(options)
+      GenAI::Chunk.new(provider: provider_name.to_sym, **options)
+    end
   end
 end

data/lib/gen_ai/chat/base.rb

@@ -18,14 +18,14 @@ module GenAI
         @history = build_history(history.map(&:deep_symbolize_keys), context, examples.map(&:deep_symbolize_keys))
       end
 
-      def message(message, options = {})
+      def message(message, options = {}, &block)
         if @history.size == 1 && @history.first[:role] != 'system'
           append_to_message(message)
         else
           append_to_history({ role: USER_ROLE, content: message })
         end
 
-        response = @model.chat(@history.dup, default_options.merge(options).compact)
+        response = @model.chat(@history.dup, default_options.merge(options).compact, &block)
         append_to_history({ role: ASSISTANT_ROLE, content: response.value })
         response
       end

data/lib/gen_ai/chat.rb

@@ -4,7 +4,7 @@ module GenAI
   class Chat
     extend Forwardable
 
-    def_delegators :@chat, :start, :message
+    def_delegators :@chat, :start, :message, :history
 
     def initialize(provider, token, options: {})
       build_chat(provider, token, options)

data/lib/gen_ai/core/chunk.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GenAI
+  class Chunk
+    attr_reader :raw, :provider, :model, :value, :index
+
+    def initialize(provider:, model:, index:, raw:, value:)
+      @raw = raw
+      @index = index
+      @provider = provider
+      @model = model
+      @value = value
+    end
+  end
+end

data/lib/gen_ai/{result.rb → core/result.rb}

@@ -27,10 +27,9 @@ module GenAI
     end
 
     def completion_tokens
-      if usage['completion_tokens'] ||
-         (total_tokens && prompt_tokens)
-        total_tokens.to_i - prompt_tokens.to_i
-      end
+      return usage['completion_tokens'] if usage['completion_tokens']
+
+      total_tokens.to_i - prompt_tokens.to_i if total_tokens && prompt_tokens
     end
 
     def total_tokens

data/lib/gen_ai/image/stability_ai.rb

@@ -27,24 +27,6 @@ module GenAI
         )
       end
 
-       def variations(image, options = {})
-        model = options[:model] || DEFAULT_MODEL
-        url = "/v1/generation/stable-diffusion-xl-1024-v1-0/image-to-image"
-
-        response = client.post url, {
-          init_image: File.binread(image),
-          image_strength: 0.3,
-          'text_prompts[0][text]' => "Portrait of old Jim Morrison at age of 60, handsome, color, phot-realistic, 50mm, crisp, high-res, depth of field, composition",
-          'text_prompts[0][weight]' => 0.7
-        }, multipart: true
-
-        build_result(
-          raw: response,
-          model: model,
-          parsed: parse_response_data(response['artifacts'])
-        )
-      end
-
       def edit(image, prompt, options = {})
         model = options[:model] || DEFAULT_MODEL
         url = "/v1/generation/#{model}/image-to-image"

data/lib/gen_ai/language/gemini.rb

@@ -1,34 +1,60 @@
 # frozen_string_literal: true
 
 require 'faraday'
+require 'pry'
 
 module GenAI
   class Language
     class Gemini < Base
       include GenAI::Api::Format::Gemini
 
-      BASE_API_URL = 'https://generativelanguage.googleapis.com'
+      COMPLETION_MODEL = 'gemini-pro'
 
       def initialize(token:, options: {})
-        @token = token
-        build_client(token)
+        depends_on 'gemini-ai'
+
+        @client = ::Gemini.new(
+          credentials: {
+            service: 'generative-language-api',
+            api_key: token
+          },
+          options: { model: model(options) }
+        )
       end
 
       def complete(prompt, options = {}); end
 
-      def chat(messages, options = {})
-        response = client.post "/v1beta/models/gemini-pro:generateContent?key=#{@token}", {
+      def chat(messages, options = {}, &block)
+        if block_given?
+          response = @client.stream_generate_content(
+            generate_options(messages, options), server_sent_events: true, &chunk_process_block(block)
+          )
+          build_result(model: model(options), raw: response.first, parsed: extract_completions(response).flatten)
+        else
+          response = @client.generate_content(generate_options(messages, options))
+          build_result(model: model(options), raw: response, parsed: extract_completions(response))
+        end
+      end
+
+      private
+
+      def generate_options(messages, options)
+        {
           contents: format_messages(messages),
           generationConfig: options.except(:model)
         }
+      end
 
-        build_result(model: 'gemini-pro', raw: response, parsed: extract_completions(response))
+      def model(options)
+        options[:model] || COMPLETION_MODEL
       end
 
-      private
+      def chunk_process_block(block)
+        proc do |data|
+          chunk = build_chunk(chunk_params_from_streaming(data))
 
-      def build_client(token)
-        @client = GenAI::Api::Client.new(url: BASE_API_URL, token: nil)
+          block.call chunk
+        end
       end
     end
   end

data/lib/gen_ai/language/open_ai.rb

@@ -23,31 +23,63 @@ module GenAI
       end
 
       def complete(prompt, options = {})
-        parameters = build_completion_options(prompt, options)
+        chat_request build_completion_options(prompt, options)
+      end
 
-        response = handle_errors { client.chat(parameters: parameters) }
+      def chat(messages, options = {}, &block)
+        parameters = build_chat_options(messages, options)
 
-        build_result(model: parameters[:model], raw: response, parsed: extract_completions(response))
+        block_given? ? chat_streaming_request(parameters, block) : chat_request(parameters)
+      end
+
+      private
+
+      def build_chat_options(messages, options)
+        build_options(messages.map(&:deep_symbolize_keys), options)
+      end
+
+      def build_completion_options(prompt, options)
+        build_options([{ role: DEFAULT_ROLE, content: prompt }], options)
       end
 
-      def chat(messages, options = {})
-        parameters = {
-          messages: messages.map(&:deep_symbolize_keys),
+      def build_options(messages, options)
+        {
+          messages: messages,
           model: options.delete(:model) || COMPLETION_MODEL
         }.merge(options)
+      end
 
+      def chat_request(parameters)
         response = handle_errors { client.chat(parameters: parameters) }
 
         build_result(model: parameters[:model], raw: response, parsed: extract_completions(response))
       end
 
-      private
+      def chat_streaming_request(parameters, block)
+        chunks = {}
 
-      def build_completion_options(prompt, options)
-        {
-          messages: [{ role: DEFAULT_ROLE, content: prompt }],
-          model: options.delete(:model) || COMPLETION_MODEL
-        }.merge(options)
+        parameters[:stream] = chunk_process_block(chunks, block)
+
+        client.chat(parameters: parameters)
+
+        build_result(
+          model: parameters[:model],
+          parsed: chunks.values.map { |group| group.map(&:value).join },
+          raw: build_raw_response(chunks)
+        )
+      end
+
+      def chunk_process_block(chunks, block)
+        proc do |data|
+          chunk = build_chunk(chunk_params_from_streaming(data))
+
+          unless chunk.value.nil? || chunk.value.empty?
+            block.call chunk
+
+            chunks[chunk.index] = [] unless chunks[chunk.index]
+            chunks[chunk.index] << chunk
+          end
+        end
       end
     end
   end

data/lib/gen_ai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GenAI
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 end

data/lib/gen_ai.rb

@@ -10,6 +10,7 @@ loader.inflector.inflect(
   'stability_ai' => 'StabilityAI'
 )
 loader.ignore("#{__dir__}/gen")
+loader.collapse("#{__dir__}/gen_ai/core")
 loader.setup
 
 module GenAI

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gen-ai
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Alex Chaplinsky
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-19 00:00:00.000000000 Z
+date: 2024-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: gemini-ai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: google_palm_api
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '6.0'
 description: GenAI allows you to easily integrate Generative AI model providers like
   OpenAI, Google Vertex AI, Stability AI, etc
 email:
@@ -123,6 +137,8 @@ files:
 - lib/gen_ai/chat/gemini.rb
 - lib/gen_ai/chat/google_palm.rb
 - lib/gen_ai/chat/open_ai.rb
+- lib/gen_ai/core/chunk.rb
+- lib/gen_ai/core/result.rb
 - lib/gen_ai/dependency.rb
 - lib/gen_ai/image.rb
 - lib/gen_ai/image/base.rb
@@ -134,7 +150,6 @@ files:
 - lib/gen_ai/language/gemini.rb
 - lib/gen_ai/language/google_palm.rb
 - lib/gen_ai/language/open_ai.rb
-- lib/gen_ai/result.rb
 - lib/gen_ai/version.rb
 - sig/gen_ai.rbs
 homepage: https://github.com/alchaplinsky/gen-ai