ruby_llm_community 0.0.1 → 0.0.3

data/lib/ruby_llm/providers/anthropic/capabilities.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Determines capabilities and pricing for Anthropic models
+      module Capabilities
+        module_function
+
+        # Determines the context window size for a given model
+        # @param model_id [String] the model identifier
+        # @return [Integer] the context window size in tokens
+        def determine_context_window(_model_id)
+          # All Claude 3 and 3.5 and 3.7 models have 200K token context windows
+          200_000
+        end
+
+        # Determines the maximum output tokens for a given model
+        # @param model_id [String] the model identifier
+        # @return [Integer] the maximum output tokens
+        def determine_max_tokens(model_id)
+          case model_id
+          when /claude-3-7-sonnet/, /claude-3-5/ then 8_192
+          else 4_096
+          end
+        end
+
+        # Gets the input price per million tokens for a given model
+        # @param model_id [String] the model identifier
+        # @return [Float] the price per million tokens for input
+        def get_input_price(model_id)
+          PRICES.dig(model_family(model_id), :input) || default_input_price
+        end
+
+        # Gets the output price per million tokens for a given model
+        # @param model_id [String] the model identifier
+        # @return [Float] the price per million tokens for output
+        def get_output_price(model_id)
+          PRICES.dig(model_family(model_id), :output) || default_output_price
+        end
+
+        # Determines if a model supports vision capabilities
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports vision
+        def supports_vision?(model_id)
+          # All Claude 3, 3.5, and 3.7 models support vision
+          !model_id.match?(/claude-[12]/)
+        end
+
+        # Determines if a model supports function calling
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports functions
+        def supports_functions?(model_id)
+          model_id.match?(/claude-3/)
+        end
+
+        # Determines if a model supports JSON mode
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports JSON mode
+        def supports_json_mode?(model_id)
+          model_id.match?(/claude-3/)
+        end
+
+        # Determines if a model supports extended thinking
+        # @param model_id [String] the model identifier
+        # @return [Boolean] true if the model supports extended thinking
+        def supports_extended_thinking?(model_id)
+          model_id.match?(/claude-3-7-sonnet/)
+        end
+
+        # Determines the model family for a given model ID
+        # @param model_id [String] the model identifier
+        # @return [Symbol] the model family identifier
+        def model_family(model_id)
+          case model_id
+          when /claude-3-7-sonnet/  then 'claude-3-7-sonnet'
+          when /claude-3-5-sonnet/  then 'claude-3-5-sonnet'
+          when /claude-3-5-haiku/   then 'claude-3-5-haiku'
+          when /claude-3-opus/      then 'claude-3-opus'
+          when /claude-3-sonnet/    then 'claude-3-sonnet'
+          when /claude-3-haiku/     then 'claude-3-haiku'
+          else 'claude-2'
+          end
+        end
+
+        # Returns the model type
+        # @param model_id [String] the model identifier (unused but kept for API consistency)
+        # @return [String] the model type, always 'chat' for Anthropic models
+        def model_type(_)
+          'chat'
+        end
+
+        # Pricing information for Anthropic models (per million tokens)
+        PRICES = {
+          'claude-3-7-sonnet': { input: 3.0, output: 15.0 },
+          'claude-3-5-sonnet': { input: 3.0, output: 15.0 },
+          'claude-3-5-haiku': { input: 0.80, output: 4.0 },
+          'claude-3-opus': { input: 15.0, output: 75.0 },
+          'claude-3-haiku': { input: 0.25, output: 1.25 },
+          'claude-2': { input: 3.0, output: 15.0 }
+        }.freeze
+
+        # Default input price if model not found in PRICES
+        # @return [Float] default price per million tokens for input
+        def default_input_price
+          3.0
+        end
+
+        # Default output price if model not found in PRICES
+        # @return [Float] default price per million tokens for output
+        def default_output_price
+          15.0
+        end
+
+        def modalities_for(model_id)
+          modalities = {
+            input: ['text'],
+            output: ['text']
+          }
+
+          # All Claude 3+ models support vision
+          unless model_id.match?(/claude-[12]/)
+            modalities[:input] << 'image'
+            modalities[:input] << 'pdf'
+          end
+
+          modalities
+        end
+
+        def capabilities_for(model_id)
+          capabilities = ['streaming']
+
+          # Function calling for Claude 3+
+          if model_id.match?(/claude-3/)
+            capabilities << 'function_calling'
+            capabilities << 'batch'
+          end
+
+          # Extended thinking (reasoning) for Claude 3.7
+          capabilities << 'reasoning' if model_id.match?(/claude-3-7/)
+
+          # Citations
+          capabilities << 'citations' if model_id.match?(/claude-3\.5|claude-3-7/)
+
+          capabilities
+        end
+
+        def pricing_for(model_id)
+          family = model_family(model_id)
+          prices = PRICES.fetch(family.to_sym, { input: default_input_price, output: default_output_price })
+
+          standard_pricing = {
+            input_per_million: prices[:input],
+            output_per_million: prices[:output]
+          }
+
+          # Batch is typically half the price
+          batch_pricing = {
+            input_per_million: prices[:input] * 0.5,
+            output_per_million: prices[:output] * 0.5
+          }
+
+          # Add reasoning output pricing for 3.7 models
+          if model_id.match?(/claude-3-7/)
+            standard_pricing[:reasoning_output_per_million] = prices[:output] * 2.5
+            batch_pricing[:reasoning_output_per_million] = prices[:output] * 1.25
+          end
+
+          {
+            text_tokens: {
+              standard: standard_pricing,
+              batch: batch_pricing
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/anthropic/chat.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Chat methods of the OpenAI API integration
+      module Chat
+        module_function
+
+        def completion_url
+          '/v1/messages'
+        end
+
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+                           cache_prompts: { system: false, user: false, tools: false })
+          system_messages, chat_messages = separate_messages(messages)
+          system_content = build_system_content(system_messages, cache: cache_prompts[:system])
+
+          build_base_payload(chat_messages, model, stream, cache: cache_prompts[:user]).tap do |payload|
+            add_optional_fields(payload, system_content:, tools:, temperature:,
+                                         cache_tools: cache_prompts[:tools])
+          end
+        end
+
+        def separate_messages(messages)
+          messages.partition { |msg| msg.role == :system }
+        end
+
+        def build_system_content(system_messages, cache: false)
+          system_messages.flat_map.with_index do |msg, idx|
+            message_cache = cache if idx == system_messages.size - 1
+            format_system_message(msg, cache: message_cache)
+          end
+        end
+
+        def build_base_payload(chat_messages, model, stream, cache: false)
+          messages = chat_messages.map.with_index do |msg, idx|
+            message_cache = cache if idx == chat_messages.size - 1
+            format_message(msg, cache: message_cache)
+          end
+
+          {
+            model: model,
+            messages:,
+            stream: stream,
+            max_tokens: RubyLLM.models.find(model)&.max_tokens || 4096
+          }
+        end
+
+        def add_optional_fields(payload, system_content:, tools:, temperature:, cache_tools: false)
+          if tools.any?
+            tool_definitions = tools.values.map { |t| Tools.function_for(t) }
+            tool_definitions[-1][:cache_control] = { type: 'ephemeral' } if cache_tools
+            payload[:tools] = tool_definitions
+          end
+
+          payload[:system] = system_content unless system_content.empty?
+          payload[:temperature] = temperature unless temperature.nil?
+        end
+
+        def parse_completion_response(response)
+          data = response.body
+          content_blocks = data['content'] || []
+
+          text_content = extract_text_content(content_blocks)
+          tool_use_blocks = Tools.find_tool_uses(content_blocks)
+
+          build_message(data, text_content, tool_use_blocks, response)
+        end
+
+        def extract_text_content(blocks)
+          text_blocks = blocks.select { |c| c['type'] == 'text' }
+          text_blocks.map { |c| c['text'] }.join
+        end
+
+        def build_message(data, content, tool_use_blocks, response)
+          Message.new(
+            role: :assistant,
+            content: content,
+            tool_calls: Tools.parse_tool_calls(tool_use_blocks),
+            input_tokens: data.dig('usage', 'input_tokens'),
+            output_tokens: data.dig('usage', 'output_tokens'),
+            model_id: data['model'],
+            cache_creation_tokens: data.dig('usage', 'cache_creation_input_tokens'),
+            cached_tokens: data.dig('usage', 'cache_read_input_tokens'),
+            raw: response
+          )
+        end
+
+        def format_message(msg, cache: false)
+          if msg.tool_call?
+            Tools.format_tool_call(msg)
+          elsif msg.tool_result?
+            Tools.format_tool_result(msg)
+          else
+            format_basic_message(msg, cache:)
+          end
+        end
+
+        def format_system_message(msg, cache: false)
+          Media.format_content(msg.content, cache:)
+        end
+
+        def format_basic_message(msg, cache: false)
+          {
+            role: convert_role(msg.role),
+            content: Media.format_content(msg.content, cache:)
+          }
+        end
+
+        def convert_role(role)
+          case role
+          when :tool, :user then 'user'
+          else 'assistant'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/anthropic/embeddings.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Embeddings methods of the Anthropic API integration
+      module Embeddings
+        private
+
+        def embed
+          raise Error "Anthropic doesn't support embeddings"
+        end
+
+        alias render_embedding_payload embed
+        alias embedding_url embed
+        alias parse_embedding_response embed
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/anthropic/media.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Handles formatting of media content (images, PDFs, audio) for Anthropic
+      module Media
+        module_function
+
+        def format_content(content, cache: false)
+          # Convert Hash/Array back to JSON string for API
+          return [format_text(content.to_json, cache:)] if content.is_a?(Hash) || content.is_a?(Array)
+          return [format_text(content, cache:)] unless content.is_a?(Content)
+
+          parts = []
+          parts << format_text(content.text, cache:) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment.type
+            when :image
+              parts << format_image(attachment)
+            when :pdf
+              parts << format_pdf(attachment)
+            when :text
+              parts << format_text_file(attachment)
+            else
+              raise UnsupportedAttachmentError, attachment.mime_type
+            end
+          end
+
+          parts
+        end
+
+        def format_text(text, cache: false)
+          with_cache_control(
+            {
+              type: 'text',
+              text: text
+            },
+            cache:
+          )
+        end
+
+        def format_image(image, cache: false)
+          if image.url?
+            with_cache_control(
+              {
+                type: 'image',
+                source: {
+                  type: 'url',
+                  url: image.source
+                }
+              },
+              cache:
+            )
+          else
+            with_cache_control(
+              {
+                type: 'image',
+                source: {
+                  type: 'base64',
+                  media_type: image.mime_type,
+                  data: image.encoded
+                }
+              },
+              cache:
+            )
+          end
+        end
+
+        def format_pdf(pdf, cache: false)
+          if pdf.url?
+            with_cache_control(
+              {
+                type: 'document',
+                source: {
+                  type: 'url',
+                  url: pdf.source
+                }
+              },
+              cache:
+            )
+          else
+            with_cache_control(
+              {
+                type: 'document',
+                source: {
+                  type: 'base64',
+                  media_type: pdf.mime_type,
+                  data: pdf.encoded
+                }
+              },
+              cache:
+            )
+          end
+        end
+
+        def format_text_file(text_file, cache: false)
+          with_cache_control(
+            {
+              type: 'text',
+              text: Utils.format_text_file_for_llm(text_file)
+            },
+            cache:
+          )
+        end
+
+        def with_cache_control(hash, cache: false)
+          return hash unless cache
+
+          hash.merge(cache_control: { type: 'ephemeral' })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Models methods of the Anthropic API integration
+      module Models
+        module_function
+
+        def models_url
+          '/v1/models'
+        end
+
+        def parse_list_models_response(response, slug, capabilities)
+          Array(response.body['data']).map do |model_data|
+            model_id = model_data['id']
+
+            Model::Info.new(
+              id: model_id,
+              name: model_data['display_name'],
+              provider: slug,
+              family: capabilities.model_family(model_id),
+              created_at: Time.parse(model_data['created_at']),
+              context_window: capabilities.determine_context_window(model_id),
+              max_output_tokens: capabilities.determine_max_tokens(model_id),
+              modalities: capabilities.modalities_for(model_id),
+              capabilities: capabilities.capabilities_for(model_id),
+              pricing: capabilities.pricing_for(model_id),
+              metadata: {}
+            )
+          end
+        end
+
+        def extract_model_id(data)
+          data.dig('message', 'model')
+        end
+
+        def extract_input_tokens(data)
+          data.dig('message', 'usage', 'input_tokens')
+        end
+
+        def extract_output_tokens(data)
+          data.dig('message', 'usage', 'output_tokens') || data.dig('usage', 'output_tokens')
+        end
+
+        def extract_cached_tokens(data)
+          data.dig('message', 'usage', 'cache_read_input_tokens')
+        end
+
+        def extract_cache_creation_tokens(data)
+          data.dig('message', 'usage', 'cache_creation_input_tokens')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Streaming methods of the Anthropic API integration
+      module Streaming
+        private
+
+        def stream_url
+          completion_url
+        end
+
+        def build_chunk(data)
+          Chunk.new(
+            role: :assistant,
+            model_id: extract_model_id(data),
+            content: data.dig('delta', 'text'),
+            input_tokens: extract_input_tokens(data),
+            output_tokens: extract_output_tokens(data),
+            cached_tokens: extract_cached_tokens(data),
+            cache_creation_tokens: extract_cache_creation_tokens(data),
+            tool_calls: extract_tool_calls(data)
+          )
+        end
+
+        def json_delta?(data)
+          data['type'] == 'content_block_delta' && data.dig('delta', 'type') == 'input_json_delta'
+        end
+
+        def parse_streaming_error(data)
+          error_data = JSON.parse(data)
+          return unless error_data['type'] == 'error'
+
+          case error_data.dig('error', 'type')
+          when 'overloaded_error'
+            [529, error_data['error']['message']]
+          else
+            [500, error_data['error']['message']]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/anthropic/tools.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Tools methods of the Anthropic API integration
+      module Tools
+        module_function
+
+        def find_tool_uses(blocks)
+          blocks.select { |c| c['type'] == 'tool_use' }
+        end
+
+        def format_tool_call(msg)
+          content = []
+
+          content << Media.format_text(msg.content) unless msg.content.nil? || msg.content.empty?
+
+          msg.tool_calls.each_value do |tool_call|
+            content << format_tool_use_block(tool_call)
+          end
+
+          {
+            role: 'assistant',
+            content:
+          }
+        end
+
+        def format_tool_result(msg)
+          {
+            role: 'user',
+            content: [format_tool_result_block(msg)]
+          }
+        end
+
+        def format_tool_use_block(tool_call)
+          {
+            type: 'tool_use',
+            id: tool_call.id,
+            name: tool_call.name,
+            input: tool_call.arguments
+          }
+        end
+
+        def format_tool_result_block(msg)
+          {
+            type: 'tool_result',
+            tool_use_id: msg.tool_call_id,
+            content: msg.content
+          }
+        end
+
+        def function_for(tool)
+          {
+            name: tool.name,
+            description: tool.description,
+            input_schema: {
+              type: 'object',
+              properties: clean_parameters(tool.parameters),
+              required: required_parameters(tool.parameters)
+            }
+          }
+        end
+
+        def extract_tool_calls(data)
+          if json_delta?(data)
+            { nil => ToolCall.new(id: nil, name: nil, arguments: data.dig('delta', 'partial_json')) }
+          else
+            parse_tool_calls(data['content_block'])
+          end
+        end
+
+        def parse_tool_calls(content_blocks)
+          return nil if content_blocks.nil?
+
+          # Handle single content block (backward compatibility)
+          content_blocks = [content_blocks] unless content_blocks.is_a?(Array)
+
+          tool_calls = {}
+          content_blocks.each do |block|
+            next unless block && block['type'] == 'tool_use'
+
+            tool_calls[block['id']] = ToolCall.new(
+              id: block['id'],
+              name: block['name'],
+              arguments: block['input']
+            )
+          end
+
+          tool_calls.empty? ? nil : tool_calls
+        end
+
+        def clean_parameters(parameters)
+          parameters.transform_values do |param|
+            {
+              type: param.type,
+              description: param.description
+            }.compact
+          end
+        end
+
+        def required_parameters(parameters)
+          parameters.select { |_, param| param.required }.keys
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/anthropic.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Anthropic Claude API integration. Handles the complexities of
+    # Claude's unique message format and tool calling conventions.
+    class Anthropic < Provider
+      include Anthropic::Chat
+      include Anthropic::Embeddings
+      include Anthropic::Media
+      include Anthropic::Models
+      include Anthropic::Streaming
+      include Anthropic::Tools
+
+      def api_base
+        'https://api.anthropic.com'
+      end
+
+      def headers
+        {
+          'x-api-key' => @config.anthropic_api_key,
+          'anthropic-version' => '2023-06-01'
+        }
+      end
+
+      class << self
+        def capabilities
+          Anthropic::Capabilities
+        end
+
+        def configuration_requirements
+          %i[anthropic_api_key]
+        end
+      end
+    end
+  end
+end