ruby_llm_community 0.0.6 → 1.0.0

data/lib/ruby_llm/providers/vertexai/models.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI
+      # Models methods for the Vertex AI integration
+      module Models
+        # Gemini and other Google models that aren't returned by the API
+        KNOWN_GOOGLE_MODELS = %w[
+          gemini-2.5-flash-lite
+          gemini-2.5-pro
+          gemini-2.5-flash
+          gemini-2.0-flash-lite-001
+          gemini-2.0-flash-001
+          gemini-2.0-flash
+          gemini-2.0-flash-exp
+          gemini-1.5-pro-002
+          gemini-1.5-pro
+          gemini-1.5-flash-002
+          gemini-1.5-flash
+          gemini-1.5-flash-8b
+          gemini-pro
+          gemini-pro-vision
+          gemini-exp-1206
+          gemini-exp-1121
+          gemini-embedding-001
+          text-embedding-005
+          text-embedding-004
+          text-multilingual-embedding-002
+        ].freeze
+
+        def list_models
+          all_models = []
+          page_token = nil
+
+          all_models.concat(build_known_models)
+
+          loop do
+            response = @connection.get('publishers/google/models') do |req|
+              req.headers['x-goog-user-project'] = @config.vertexai_project_id
+              req.params = { pageSize: 100 }
+              req.params[:pageToken] = page_token if page_token
+            end
+
+            publisher_models = response.body['publisherModels'] || []
+            publisher_models.each do |model_data|
+              next if model_data['launchStage'] == 'DEPRECATED'
+
+              model_id = extract_model_id_from_path(model_data['name'])
+              all_models << build_model_from_api_data(model_data, model_id)
+            end
+
+            page_token = response.body['nextPageToken']
+            break unless page_token
+          end
+
+          all_models
+        rescue StandardError => e
+          RubyLLM.logger.debug "Error fetching Vertex AI models: #{e.message}"
+          build_known_models
+        end
+
+        private
+
+        def build_known_models
+          KNOWN_GOOGLE_MODELS.map do |model_id|
+            Model::Info.new(
+              id: model_id,
+              name: model_id,
+              provider: slug,
+              family: determine_model_family(model_id),
+              created_at: nil,
+              context_window: nil,
+              max_output_tokens: nil,
+              modalities: nil,
+              capabilities: %w[streaming function_calling],
+              pricing: nil,
+              metadata: {
+                source: 'known_models'
+              }
+            )
+          end
+        end
+
+        def build_model_from_api_data(model_data, model_id)
+          Model::Info.new(
+            id: model_id,
+            name: model_id,
+            provider: slug,
+            family: determine_model_family(model_id),
+            created_at: nil,
+            context_window: nil,
+            max_output_tokens: nil,
+            modalities: nil,
+            capabilities: extract_capabilities(model_data),
+            pricing: nil,
+            metadata: {
+              version_id: model_data['versionId'],
+              open_source_category: model_data['openSourceCategory'],
+              launch_stage: model_data['launchStage'],
+              supported_actions: model_data['supportedActions'],
+              publisher_model_template: model_data['publisherModelTemplate']
+            }
+          )
+        end
+
+        def extract_model_id_from_path(path)
+          path.split('/').last
+        end
+
+        def determine_model_family(model_id)
+          case model_id
+          when /^gemini-2\.\d+/ then 'gemini-2'
+          when /^gemini-1\.\d+/ then 'gemini-1.5'
+          when /^text-embedding/ then 'text-embedding'
+          when /bison/ then 'palm'
+          else 'gemini'
+          end
+        end
+
+        def extract_capabilities(model_data)
+          capabilities = ['streaming']
+          model_name = model_data['name']
+          capabilities << 'function_calling' if model_name.include?('gemini')
+          capabilities.uniq
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/vertexai/streaming.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI
+      # Streaming methods for the Vertex AI implementation
+      module Streaming
+        def stream_url
+          "projects/#{@config.vertexai_project_id}/locations/#{@config.vertexai_location}/publishers/google/models/#{@model}:streamGenerateContent?alt=sse" # rubocop:disable Layout/LineLength
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/vertexai.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Google Vertex AI implementation
+    class VertexAI < Gemini
+      include VertexAI::Chat
+      include VertexAI::Streaming
+      include VertexAI::Embeddings
+      include VertexAI::Models
+
+      def initialize(config)
+        super
+        @authorizer = nil
+      end
+
+      def api_base
+        "https://#{@config.vertexai_location}-aiplatform.googleapis.com/v1beta1"
+      end
+
+      def headers
+        {
+          'Authorization' => "Bearer #{access_token}"
+        }
+      end
+
+      class << self
+        def configuration_requirements
+          %i[vertexai_project_id vertexai_location]
+        end
+      end
+
+      private
+
+      def access_token
+        return 'test-token' if defined?(VCR) && VCR.current_cassette
+
+        initialize_authorizer unless @authorizer
+        @authorizer.fetch_access_token!['access_token']
+      end
+
+      def initialize_authorizer
+        require 'googleauth'
+        @authorizer = ::Google::Auth.get_application_default(
+          scope: [
+            'https://www.googleapis.com/auth/cloud-platform',
+            'https://www.googleapis.com/auth/generative-language.retriever'
+          ]
+        )
+      rescue LoadError
+        raise Error, 'The googleauth gem is required for Vertex AI. Please add it to your Gemfile: gem "googleauth"'
+      end
+    end
+  end
+end

data/lib/ruby_llm/railtie.rb

@@ -9,7 +9,6 @@ module RubyLLM
       end
     end
 
-    # Register generators
     generators do
       require 'generators/ruby_llm/install_generator'
     end

data/lib/ruby_llm/stream_accumulator.rb

@@ -2,29 +2,29 @@
 
 module RubyLLM
   # Assembles streaming responses from LLMs into complete messages.
-  # Handles the complexities of accumulating content and tool calls
-  # from partial chunks while tracking token usage.
   class StreamAccumulator
     attr_reader :content, :model_id, :tool_calls
 
     def initialize
-      @content = +''
+      @content = nil
       @tool_calls = {}
       @input_tokens = 0
       @output_tokens = 0
       @cached_tokens = 0
       @cache_creation_tokens = 0
       @latest_tool_call_id = nil
+      @reasoning_id = nil
     end
 
     def add(chunk)
       RubyLLM.logger.debug chunk.inspect if RubyLLM.config.log_stream_debug
       @model_id ||= chunk.model_id
+      @reasoning_id ||= chunk.reasoning_id
 
       if chunk.tool_call?
         accumulate_tool_calls chunk.tool_calls
       else
-        @content << (chunk.content || '')
+        accumulate_content(chunk.content)
       end
 
       count_tokens chunk
@@ -32,27 +32,89 @@ module RubyLLM
     end
 
     def to_message(response)
+      content = final_content
+      associate_reasoning_with_images(content)
+
       Message.new(
         role: :assistant,
-        content: content.empty? ? nil : content,
+        content: content,
         model_id: model_id,
         tool_calls: tool_calls_from_stream,
-        input_tokens: @input_tokens.positive? ? @input_tokens : nil,
-        output_tokens: @output_tokens.positive? ? @output_tokens : nil,
-        cached_tokens: @cached_tokens.positive? ? @cached_tokens : nil,
-        cache_creation_tokens: @cache_creation_tokens.positive? ? @cache_creation_tokens : nil,
+        input_tokens: positive_or_nil(@input_tokens),
+        output_tokens: positive_or_nil(@output_tokens),
+        cached_tokens: positive_or_nil(@cached_tokens),
+        cache_creation_tokens: positive_or_nil(@cache_creation_tokens),
         raw: response
       )
     end
 
     private
 
+    def associate_reasoning_with_images(content)
+      return unless @reasoning_id && content.is_a?(Content) && content.attachments.any?
+
+      content.attachments.each do |attachment|
+        attachment.instance_variable_set(:@reasoning_id, @reasoning_id) if attachment.is_a?(ImageAttachment)
+      end
+    end
+
+    def positive_or_nil(value)
+      value.positive? ? value : nil
+    end
+
+    def accumulate_content(new_content)
+      return unless new_content
+
+      if @content.nil?
+        @content = new_content.is_a?(String) ? +new_content : new_content
+      else
+        case [@content.class, new_content.class]
+        when [String, String]
+          @content << new_content
+        when [String, Content]
+          # Convert accumulated string to Content and merge
+          @content = Content.new(@content)
+          merge_content(new_content)
+        when [Content, String]
+          # Append string to existing Content's text
+          @content.instance_variable_set(:@text, (@content.text || '') + new_content)
+        when [Content, Content]
+          merge_content(new_content)
+        end
+      end
+    end
+
+    def merge_content(new_content)
+      # Merge text
+      current_text = @content.text || ''
+      new_text = new_content.text || ''
+      @content.instance_variable_set(:@text, current_text + new_text)
+
+      # Merge attachments
+      new_content.attachments.each do |attachment|
+        @content.attach(attachment)
+      end
+    end
+
+    def final_content
+      case @content
+      when nil
+        nil
+      when String
+        @content.empty? ? nil : @content
+      when Content
+        @content.text.nil? && @content.attachments.empty? ? nil : @content
+      else
+        @content
+      end
+    end
+
     def tool_calls_from_stream
       tool_calls.transform_values do |tc|
         arguments = if tc.arguments.is_a?(String) && !tc.arguments.empty?
                       JSON.parse(tc.arguments)
                     elsif tc.arguments.is_a?(String)
-                      {} # Return empty hash for empty string arguments
+                      {}
                     else
                       tc.arguments
                     end

data/lib/ruby_llm/streaming.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  # Handles streaming responses from AI providers. Provides a unified way to process
-  # chunked responses, accumulate content, and handle provider-specific streaming formats.
-  # Each provider implements provider-specific parsing while sharing common stream handling
-  # patterns.
+  # Handles streaming responses from AI providers.
   module Streaming
     module_function
 
@@ -12,17 +9,14 @@ module RubyLLM
       accumulator = StreamAccumulator.new
 
       response = connection.post stream_url, payload do |req|
-        # Merge additional headers, with existing headers taking precedence
         req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
-        if req.options.respond_to?(:on_data)
-          # Handle Faraday 2.x streaming with on_data method
-          req.options.on_data = handle_stream do |chunk|
+        if faraday_1?
+          req.options[:on_data] = handle_stream do |chunk|
             accumulator.add chunk
             block.call chunk
           end
         else
-          # Handle Faraday 1.x streaming with :on_data key
-          req.options[:on_data] = handle_stream do |chunk|
+          req.options.on_data = handle_stream do |chunk|
             accumulator.add chunk
             block.call chunk
           end
@@ -30,7 +24,7 @@ module RubyLLM
       end
 
       message = accumulator.to_message(response)
-      RubyLLM.logger.debug "Stream completed: #{message.inspect}"
+      RubyLLM.logger.debug "Stream completed: #{message.content}"
       message
     end
 
@@ -42,6 +36,10 @@ module RubyLLM
 
     private
 
+    def faraday_1?
+      Faraday::VERSION.start_with?('1')
+    end
+
     def to_json_stream(&)
       buffer = +''
       parser = EventStreamParser::Parser.new
@@ -50,11 +48,9 @@ module RubyLLM
     end
 
     def create_stream_processor(parser, buffer, &)
-      if Faraday::VERSION.start_with?('1')
-        # Faraday 1.x: on_data receives (chunk, size)
+      if faraday_1?
         legacy_stream_processor(parser, &)
       else
-        # Faraday 2.x: on_data receives (chunk, bytes, env)
         stream_processor(parser, buffer, &)
       end
     end
@@ -94,12 +90,10 @@ module RubyLLM
       status, _message = parse_streaming_error(error_data)
       parsed_data = JSON.parse(error_data)
 
-      # Create a response-like object that works for both Faraday v1 and v2
-      error_response = if env
-                         env.merge(body: parsed_data, status: status)
-                       else
-                         # For Faraday v1, create a simple object that responds to .status and .body
+      error_response = if faraday_1?
                          Struct.new(:body, :status).new(parsed_data, status)
+                       else
+                         env.merge(body: parsed_data, status: status)
                        end
 
       ErrorMiddleware.parse_error(provider: self, response: error_response)
@@ -137,12 +131,10 @@ module RubyLLM
       status, _message = parse_streaming_error(data)
       parsed_data = JSON.parse(data)
 
-      # Create a response-like object that works for both Faraday v1 and v2
-      error_response = if env
-                         env.merge(body: parsed_data, status: status)
-                       else
-                         # For Faraday v1, create a simple object that responds to .status and .body
+      error_response = if faraday_1?
                          Struct.new(:body, :status).new(parsed_data, status)
+                       else
+                         env.merge(body: parsed_data, status: status)
                        end
 
       ErrorMiddleware.parse_error(provider: self, response: error_response)
@@ -150,7 +142,6 @@ module RubyLLM
       RubyLLM.logger.debug "Failed to parse error event: #{e.message}"
     end
 
-    # Default implementation - providers should override this method
     def parse_streaming_error(data)
       error_data = JSON.parse(data)
       [500, error_data['message'] || 'Unknown streaming error']

data/lib/ruby_llm/tool.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  # Parameter definition for Tool methods. Specifies type constraints,
-  # descriptions, and whether parameters are required.
+  # Parameter definition for Tool methods.
   class Parameter
     attr_reader :name, :type, :description, :required
 
@@ -14,23 +13,7 @@ module RubyLLM
     end
   end
 
-  # Base class for creating tools that AI models can use. Provides a simple
-  # interface for defining parameters and implementing tool behavior.
-  #
-  # Example:
-  #    require 'tzinfo'
-  #
-  #    class TimeInfo < RubyLLM::Tool
-  #      description 'Gets the current time in various timezones'
-  #      param :timezone, desc: "Timezone name (e.g., 'UTC', 'America/New_York')"
-  #
-  #      def execute(timezone:)
-  #        time = TZInfo::Timezone.get(timezone).now.strftime('%Y-%m-%d %H:%M:%S')
-  #        "Current time in #{timezone}: #{time}"
-  #       rescue StandardError => e
-  #          { error: e.message }
-  #       end
-  #    end
+  # Base class for creating tools that AI models can use
   class Tool
     # Stops conversation continuation after tool execution
     class Halt

data/lib/ruby_llm/tool_call.rb

@@ -2,15 +2,6 @@
 
 module RubyLLM
   # Represents a function call from an AI model to a Tool.
-  # Encapsulates the function name, arguments, and execution results
-  # in a clean Ruby interface.
-  #
-  # Example:
-  #   tool_call = ToolCall.new(
-  #     id: "call_123",
-  #     name: "calculator",
-  #     arguments: { expression: "2 + 2" }
-  #   )
   class ToolCall
     attr_reader :id, :name, :arguments
 

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '0.0.6'
+  VERSION = '1.0.0'
 end

data/lib/ruby_llm_community.rb

@@ -4,6 +4,8 @@ require 'base64'
 require 'event_stream_parser'
 require 'faraday'
 require 'faraday/retry'
+require 'faraday/multipart'
+
 require 'json'
 require 'logger'
 require 'securerandom'
@@ -23,7 +25,8 @@ loader.inflector.inflect(
   'gpustack' => 'GPUStack',
   'mistral' => 'Mistral',
   'pdf' => 'PDF',
-  'version' => 'VERSION'
+  'version' => 'VERSION',
+  'vertexai' => 'VertexAI'
 )
 loader.ignore("#{__dir__}/shims")
 loader.ignore("#{__dir__}/tasks")
@@ -37,8 +40,6 @@ module RubyLlmCommunity
 end
 
 # A delightful Ruby interface to modern AI language models.
-# Provides a unified way to interact with models from OpenAI, Anthropic and others
-# with a focus on developer happiness and convention over configuration.
 module RubyLLM
   class Error < StandardError; end
 
@@ -97,6 +98,7 @@ RubyLLM::Provider.register :ollama, RubyLLM::Providers::Ollama
 RubyLLM::Provider.register :openai, RubyLLM::Providers::OpenAI
 RubyLLM::Provider.register :openrouter, RubyLLM::Providers::OpenRouter
 RubyLLM::Provider.register :perplexity, RubyLLM::Providers::Perplexity
+RubyLLM::Provider.register :vertexai, RubyLLM::Providers::VertexAI
 
 if defined?(Rails::Railtie)
   require 'ruby_llm/railtie'