ruby_llm 0.1.0.pre30 → 0.1.0.pre33

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Anthropic
+      # Determines capabilities and pricing for Anthropic models
+      module Capabilities
+        module_function
+
+        def determine_context_window(model_id)
+          case model_id
+          when /claude-3/ then 200_000
+          else 100_000
+          end
+        end
+
+        def determine_max_tokens(model_id)
+          case model_id
+          when /claude-3-5/ then 8_192
+          else 4_096
+          end
+        end
+
+        def get_input_price(model_id)
+          PRICES.dig(model_family(model_id), :input) || default_input_price
+        end
+
+        def get_output_price(model_id)
+          PRICES.dig(model_family(model_id), :output) || default_output_price
+        end
+
+        def supports_vision?(model_id)
+          return false if model_id.match?(/claude-3-5-haiku/)
+          return false if model_id.match?(/claude-[12]/)
+
+          true
+        end
+
+        def supports_functions?(model_id)
+          model_id.include?('claude-3')
+        end
+
+        def supports_json_mode?(model_id)
+          model_id.include?('claude-3')
+        end
+
+        def model_family(model_id)
+          case model_id
+          when /claude-3-5-sonnet/  then :claude35_sonnet
+          when /claude-3-5-haiku/   then :claude35_haiku
+          when /claude-3-opus/      then :claude3_opus
+          when /claude-3-sonnet/    then :claude3_sonnet
+          when /claude-3-haiku/     then :claude3_haiku
+          else :claude2
+          end
+        end
+
+        def model_type(_)
+          'chat'
+        end
+
+        PRICES = {
+          claude35_sonnet: { input: 3.0, output: 15.0 }, # $3.00/$15.00 per million tokens
+          claude35_haiku: { input: 0.80, output: 4.0 }, # $0.80/$4.00 per million tokens
+          claude3_opus: { input: 15.0, output: 75.0 }, # $15.00/$75.00 per million tokens
+          claude3_sonnet: { input: 3.0, output: 15.0 }, # $3.00/$15.00 per million tokens
+          claude3_haiku: { input: 0.25, output: 1.25 }, # $0.25/$1.25 per million tokens
+          claude2: { input: 3.0,  output: 15.0 } # Default pricing for Claude 2.x models
+        }.freeze
+
+        def default_input_price
+          3.0
+        end
+
+        def default_output_price
+          15.0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Anthropic
+      # Chat methods of the OpenAI API integration
+      module Chat
+        private
+
+        def completion_url
+          '/v1/messages'
+        end
+
+        def render_payload(messages, tools:, temperature:, model:, stream: false)
+          {
+            model: model,
+            messages: messages.map { |msg| format_message(msg) },
+            temperature: temperature,
+            stream: stream,
+            max_tokens: RubyLLM.models.find(model).max_tokens
+          }.tap do |payload|
+            payload[:tools] = tools.values.map { |t| function_for(t) } if tools.any?
+          end
+        end
+
+        def parse_completion_response(response)
+          data = response.body
+          content_blocks = data['content'] || []
+
+          text_content = extract_text_content(content_blocks)
+          tool_use = find_tool_use(content_blocks)
+
+          build_message(data, text_content, tool_use)
+        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)
+          Message.new(
+            role: :assistant,
+            content: content,
+            tool_calls: parse_tool_calls(tool_use),
+            input_tokens: data.dig('usage', 'input_tokens'),
+            output_tokens: data.dig('usage', 'output_tokens'),
+            model_id: data['model']
+          )
+        end
+
+        def format_message(msg)
+          if msg.tool_call?
+            format_tool_call(msg)
+          elsif msg.tool_result?
+            format_tool_result(msg)
+          else
+            format_basic_message(msg)
+          end
+        end
+
+        def format_basic_message(msg)
+          {
+            role: convert_role(msg.role),
+            content: msg.content
+          }
+        end
+
+        def convert_role(role)
+          case role
+          when :tool then 'user'
+          when :user then 'user'
+          else 'assistant'
+          end
+        end
+
+        def format_text_block(content)
+          {
+            type: 'text',
+            text: content
+          }
+        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
+    module 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/models.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Anthropic
+      # Models methods of the Anthropic API integration
+      module Models
+        private
+
+        def models_url
+          '/v1/models'
+        end
+
+        def parse_list_models_response(response) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          (response.body['data'] || []).map do |model|
+            ModelInfo.new(
+              id: model['id'],
+              created_at: Time.parse(model['created_at']),
+              display_name: model['display_name'],
+              provider: slug,
+              type: capabilities.model_type(model['id']),
+              family: capabilities.model_family(model['id']),
+              context_window: capabilities.determine_context_window(model['id']),
+              max_tokens: capabilities.determine_max_tokens(model['id']),
+              supports_vision: capabilities.supports_vision?(model['id']),
+              supports_functions: capabilities.supports_functions?(model['id']),
+              supports_json_mode: capabilities.supports_json_mode?(model['id']),
+              input_price_per_million: capabilities.get_input_price(model['id']),
+              output_price_per_million: capabilities.get_output_price(model['id'])
+            )
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Anthropic
+      # Streaming methods of the Anthropic API integration
+      module Streaming
+        private
+
+        def stream_url
+          completion_url
+        end
+
+        def handle_stream(&block)
+          to_json_stream do |data|
+            block.call(build_chunk(data))
+          end
+        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),
+            tool_calls: extract_tool_calls(data)
+          )
+        end
+
+        def json_delta?(data)
+          data['type'] == 'content_block_delta' && data.dig('delta', 'type') == 'input_json_delta'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Anthropic
+      # Tools methods of the Anthropic API integration
+      module Tools
+        private
+
+        def find_tool_use(blocks)
+          blocks.find { |c| c['type'] == 'tool_use' }
+        end
+
+        def format_tool_call(msg)
+          tool_call = msg.tool_calls.values.first
+
+          {
+            role: 'assistant',
+            content: [
+              format_text_block(msg.content),
+              format_tool_use_block(tool_call)
+            ]
+          }
+        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_block)
+          return nil unless content_block && content_block['type'] == 'tool_use'
+
+          {
+            content_block['id'] => ToolCall.new(
+              id: content_block['id'],
+              name: content_block['name'],
+              arguments: content_block['input']
+            )
+          }
+        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

@@ -4,17 +4,15 @@ module RubyLLM
   module Providers
     # Anthropic Claude API integration. Handles the complexities of
     # Claude's unique message format and tool calling conventions.
-    class Anthropic # rubocop:disable Metrics/ClassLength
-      include Provider
+    module Anthropic
+      extend Provider
+      extend Anthropic::Chat
+      extend Anthropic::Embeddings
+      extend Anthropic::Models
+      extend Anthropic::Streaming
+      extend Anthropic::Tools
 
-      def parse_error(response)
-        return if response.body.empty?
-
-        body = try_parse_json(response.body)
-        body.is_a?(Hash) ? body.dig('error', 'message') : body
-      end
-
-      private
+      module_function
 
       def api_base
         'https://api.anthropic.com'
@@ -26,230 +24,6 @@ module RubyLLM
           'anthropic-version' => '2023-06-01'
         }
       end
-
-      def completion_url
-        '/v1/messages'
-      end
-
-      def stream_url
-        completion_url
-      end
-
-      def models_url
-        '/v1/models'
-      end
-
-      def build_payload(messages, tools:, temperature:, model:, stream: false)
-        {
-          model: model,
-          messages: format_messages(messages),
-          temperature: temperature,
-          stream: stream,
-          max_tokens: RubyLLM.models.find(model).max_tokens
-        }.tap do |payload|
-          payload[:tools] = tools.values.map { |t| function_for(t) } if tools.any?
-        end
-      end
-
-      def parse_completion_response(response)
-        data = response.body
-        content_blocks = data['content'] || []
-
-        text_content = extract_text_content(content_blocks)
-        tool_use = find_tool_use(content_blocks)
-
-        build_message(data, text_content, tool_use)
-      end
-
-      def extract_text_content(blocks)
-        text_blocks = blocks.select { |c| c['type'] == 'text' }
-        text_blocks.map { |c| c['text'] }.join('')
-      end
-
-      def find_tool_use(blocks)
-        blocks.find { |c| c['type'] == 'tool_use' }
-      end
-
-      def build_message(data, content, tool_use)
-        Message.new(
-          role: :assistant,
-          content: content,
-          tool_calls: parse_tool_calls(tool_use),
-          input_tokens: data.dig('usage', 'input_tokens'),
-          output_tokens: data.dig('usage', 'output_tokens'),
-          model_id: data['model']
-        )
-      end
-
-      def parse_list_models_response(response) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        (response.body['data'] || []).map do |model|
-          ModelInfo.new(
-            id: model['id'],
-            created_at: Time.parse(model['created_at']),
-            display_name: model['display_name'],
-            provider: slug,
-            type: capabilities.model_type(model['id']),
-            family: capabilities.model_family(model['id']),
-            context_window: capabilities.determine_context_window(model['id']),
-            max_tokens: capabilities.determine_max_tokens(model['id']),
-            supports_vision: capabilities.supports_vision?(model['id']),
-            supports_functions: capabilities.supports_functions?(model['id']),
-            supports_json_mode: capabilities.supports_json_mode?(model['id']),
-            input_price_per_million: capabilities.get_input_price(model['id']),
-            output_price_per_million: capabilities.get_output_price(model['id'])
-          )
-        end
-      end
-
-      def handle_stream(&block)
-        to_json_stream do |data|
-          block.call(build_chunk(data))
-        end
-      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),
-          tool_calls: extract_tool_calls(data)
-        )
-      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_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 json_delta?(data)
-        data['type'] == 'content_block_delta' && data.dig('delta', 'type') == 'input_json_delta'
-      end
-
-      def parse_tool_calls(content_block)
-        return nil unless content_block && content_block['type'] == 'tool_use'
-
-        {
-          content_block['id'] => ToolCall.new(
-            id: content_block['id'],
-            name: content_block['name'],
-            arguments: content_block['input']
-          )
-        }
-      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 format_messages(messages)
-        messages.map { |msg| format_message(msg) }
-      end
-
-      def format_message(msg)
-        if msg.tool_call?
-          format_tool_call(msg)
-        elsif msg.tool_result?
-          format_tool_result(msg)
-        else
-          format_basic_message(msg)
-        end
-      end
-
-      def format_tool_call(msg)
-        tool_call = msg.tool_calls.values.first
-
-        {
-          role: 'assistant',
-          content: [
-            format_text_block(msg.content),
-            format_tool_use_block(tool_call)
-          ]
-        }
-      end
-
-      def format_tool_result(msg)
-        {
-          role: 'user',
-          content: [format_tool_result_block(msg)]
-        }
-      end
-
-      def format_basic_message(msg)
-        {
-          role: convert_role(msg.role),
-          content: msg.content
-        }
-      end
-
-      def format_text_block(content)
-        {
-          type: 'text',
-          text: content
-        }
-      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 convert_role(role)
-        case role
-        when :tool then 'user'
-        when :user then 'user'
-        else 'assistant'
-        end
-      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