ruby_llm 0.1.0.pre30 → 0.1.0.pre31

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

data/lib/ruby_llm/providers/deepseek/capabilites.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module DeepSeek
+      # Determines capabilities and pricing for DeepSeek models
+      module Capabilities
+        module_function
+
+        def context_window_for(model_id)
+          case model_id
+          when /deepseek-(?:chat|reasoner)/ then 64_000
+          else 32_768 # Sensible default
+          end
+        end
+
+        def max_tokens_for(model_id)
+          case model_id
+          when /deepseek-(?:chat|reasoner)/ then 8_192
+          else 4_096 # Default if max_tokens not specified
+          end
+        end
+
+        def input_price_for(model_id)
+          PRICES.dig(model_family(model_id), :input_miss) || default_input_price
+        end
+
+        def output_price_for(model_id)
+          PRICES.dig(model_family(model_id), :output) || default_output_price
+        end
+
+        def cache_hit_price_for(model_id)
+          PRICES.dig(model_family(model_id), :input_hit) || default_cache_hit_price
+        end
+
+        def supports_vision?(_model_id)
+          false # DeepSeek models don't currently support vision
+        end
+
+        def supports_functions?(model_id)
+          model_id.match?(/deepseek-chat/) # Only deepseek-chat supports function calling
+        end
+
+        def supports_json_mode?(model_id)
+          model_id.match?(/deepseek-chat/) # Only deepseek-chat supports JSON mode
+        end
+
+        def format_display_name(model_id)
+          case model_id
+          when 'deepseek-chat' then 'DeepSeek V3'
+          when 'deepseek-reasoner' then 'DeepSeek R1'
+          else
+            model_id.split('-')
+                    .map(&:capitalize)
+                    .join(' ')
+          end
+        end
+
+        def model_type(_model_id)
+          'chat' # All DeepSeek models are chat models
+        end
+
+        def model_family(model_id)
+          case model_id
+          when /deepseek-chat/ then :chat
+          when /deepseek-reasoner/ then :reasoner
+          else :chat # Default to chat family
+          end
+        end
+
+        # Pricing information for DeepSeek models (USD per 1M tokens)
+        PRICES = {
+          chat: {
+            input_hit: 0.07,   # $0.07 per million tokens on cache hit
+            input_miss: 0.27,  # $0.27 per million tokens on cache miss
+            output: 1.10       # $1.10 per million tokens output
+          },
+          reasoner: {
+            input_hit: 0.14,   # $0.14 per million tokens on cache hit
+            input_miss: 0.55,  # $0.55 per million tokens on cache miss
+            output: 2.19       # $2.19 per million tokens output
+          }
+        }.freeze
+
+        private
+
+        def default_input_price
+          0.27 # Default to chat cache miss price
+        end
+
+        def default_output_price
+          1.10 # Default to chat output price
+        end
+
+        def default_cache_hit_price
+          0.07 # Default to chat cache hit price
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/deepseek.rb

@@ -3,8 +3,10 @@
 module RubyLLM
   module Providers
     # DeepSeek API integration.
-    class DeepSeek < OpenAI
-      private
+    module DeepSeek
+      extend OpenAI
+
+      module_function
 
       def api_base
         'https://api.deepseek.com'