ruby_llm_swarm 1.9.1

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Determines capabilities and pricing for Anthropic models
+      module Capabilities
+        module_function
+
+        def determine_context_window(_model_id)
+          200_000
+        end
+
+        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
+
+        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)
+          !model_id.match?(/claude-[12]/)
+        end
+
+        def supports_functions?(model_id)
+          model_id.match?(/claude-3/)
+        end
+
+        def supports_json_mode?(model_id)
+          model_id.match?(/claude-3/)
+        end
+
+        def supports_extended_thinking?(model_id)
+          model_id.match?(/claude-3-7-sonnet/)
+        end
+
+        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
+
+        def model_type(_)
+          'chat'
+        end
+
+        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
+
+        def default_input_price
+          3.0
+        end
+
+        def default_output_price
+          15.0
+        end
+
+        def modalities_for(model_id)
+          modalities = {
+            input: ['text'],
+            output: ['text']
+          }
+
+          unless model_id.match?(/claude-[12]/)
+            modalities[:input] << 'image'
+            modalities[:input] << 'pdf'
+          end
+
+          modalities
+        end
+
+        def capabilities_for(model_id)
+          capabilities = ['streaming']
+
+          if model_id.match?(/claude-3/)
+            capabilities << 'function_calling'
+            capabilities << 'batch'
+          end
+
+          capabilities << 'reasoning' if model_id.match?(/claude-3-7|-4/)
+          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_pricing = {
+            input_per_million: prices[:input] * 0.5,
+            output_per_million: prices[:output] * 0.5
+          }
+
+          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,125 @@
+# 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
+          system_messages, chat_messages = separate_messages(messages)
+          system_content = build_system_content(system_messages)
+
+          build_base_payload(chat_messages, model, stream).tap do |payload|
+            add_optional_fields(payload, system_content:, tools:, temperature:)
+          end
+        end
+
+        def separate_messages(messages)
+          messages.partition { |msg| msg.role == :system }
+        end
+
+        def build_system_content(system_messages)
+          return [] if system_messages.empty?
+
+          if system_messages.length > 1
+            RubyLLM.logger.warn(
+              "Anthropic's Claude implementation only supports a single system message. " \
+              'Multiple system messages will be combined into one.'
+            )
+          end
+
+          system_messages.flat_map do |msg|
+            content = msg.content
+
+            if content.is_a?(RubyLLM::Content::Raw)
+              content.value
+            else
+              Media.format_content(content)
+            end
+          end
+        end
+
+        def build_base_payload(chat_messages, model, stream)
+          {
+            model: model.id,
+            messages: chat_messages.map { |msg| format_message(msg) },
+            stream: stream,
+            max_tokens: model.max_tokens || 4096
+          }
+        end
+
+        def add_optional_fields(payload, system_content:, tools:, temperature:)
+          payload[:tools] = tools.values.map { |t| Tools.function_for(t) } if tools.any?
+          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)
+          usage = data['usage'] || {}
+          cached_tokens = usage['cache_read_input_tokens']
+          cache_creation_tokens = usage['cache_creation_input_tokens']
+          if cache_creation_tokens.nil? && usage['cache_creation'].is_a?(Hash)
+            cache_creation_tokens = usage['cache_creation'].values.compact.sum
+          end
+
+          Message.new(
+            role: :assistant,
+            content: content,
+            tool_calls: Tools.parse_tool_calls(tool_use_blocks),
+            input_tokens: usage['input_tokens'],
+            output_tokens: usage['output_tokens'],
+            cached_tokens: cached_tokens,
+            cache_creation_tokens: cache_creation_tokens,
+            model_id: data['model'],
+            raw: response
+          )
+        end
+
+        def format_message(msg)
+          if msg.tool_call?
+            Tools.format_tool_call(msg)
+          elsif msg.tool_result?
+            Tools.format_tool_result(msg)
+          else
+            format_basic_message(msg)
+          end
+        end
+
+        def format_basic_message(msg)
+          {
+            role: convert_role(msg.role),
+            content: Media.format_content(msg.content)
+          }
+        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/content.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Helper for constructing Anthropic native content blocks.
+      class Content
+        class << self
+          def new(text = nil, cache: false, cache_control: nil, parts: nil, **extras)
+            payload = resolve_payload(
+              text: text,
+              parts: parts,
+              cache: cache,
+              cache_control: cache_control,
+              extras: extras
+            )
+
+            RubyLLM::Content::Raw.new(payload)
+          end
+
+          private
+
+          def resolve_payload(text:, parts:, cache:, cache_control:, extras:)
+            return Array(parts) if parts
+
+            raise ArgumentError, 'text or parts must be provided' if text.nil?
+
+            block = { type: 'text', text: text }.merge(extras)
+            control = determine_cache_control(cache_control, cache)
+            block[:cache_control] = control if control
+
+            [block]
+          end
+
+          def determine_cache_control(cache_control, cache_flag)
+            return cache_control if cache_control
+
+            { type: 'ephemeral' } if cache_flag
+          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,92 @@
+# 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) # rubocop:disable Metrics/PerceivedComplexity
+          return content.value if content.is_a?(RubyLLM::Content::Raw)
+          return [format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
+          return [format_text(content)] unless content.is_a?(RubyLLM::Content)
+
+          parts = []
+          parts << format_text(content.text) 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)
+          {
+            type: 'text',
+            text: text
+          }
+        end
+
+        def format_image(image)
+          if image.url?
+            {
+              type: 'image',
+              source: {
+                type: 'url',
+                url: image.source
+              }
+            }
+          else
+            {
+              type: 'image',
+              source: {
+                type: 'base64',
+                media_type: image.mime_type,
+                data: image.encoded
+              }
+            }
+          end
+        end
+
+        def format_pdf(pdf)
+          if pdf.url?
+            {
+              type: 'document',
+              source: {
+                type: 'url',
+                url: pdf.source
+              }
+            }
+          else
+            {
+              type: 'document',
+              source: {
+                type: 'base64',
+                media_type: pdf.mime_type,
+                data: pdf.encoded
+              }
+            }
+          end
+        end
+
+        def format_text_file(text_file)
+          {
+            type: 'text',
+            text: text_file.for_llm
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# 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') || data.dig('usage', 'cache_read_input_tokens')
+        end
+
+        def extract_cache_creation_tokens(data)
+          direct = data.dig('message', 'usage',
+                            'cache_creation_input_tokens') || data.dig('usage', 'cache_creation_input_tokens')
+          return direct if direct
+
+          breakdown = data.dig('message', 'usage', 'cache_creation') || data.dig('usage', 'cache_creation')
+          return unless breakdown.is_a?(Hash)
+
+          breakdown.values.compact.sum
+        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,109 @@
+# 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)
+          return { role: 'assistant', content: msg.content.value } if msg.content.is_a?(RubyLLM::Content::Raw)
+
+          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: msg.content.is_a?(RubyLLM::Content::Raw) ? msg.content.value : [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: Media.format_content(msg.content)
+          }
+        end
+
+        def function_for(tool)
+          input_schema = tool.params_schema ||
+                         RubyLLM::Tool::SchemaDefinition.from_parameters(tool.parameters)&.json_schema
+
+          declaration = {
+            name: tool.name,
+            description: tool.description,
+            input_schema: input_schema || default_input_schema
+          }
+
+          return declaration if tool.provider_params.empty?
+
+          RubyLLM::Utils.deep_merge(declaration, tool.provider_params)
+        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?
+
+          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 default_input_schema
+          {
+            'type' => 'object',
+            'properties' => {},
+            'required' => [],
+            'additionalProperties' => false,
+            'strict' => true
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/anthropic.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Anthropic Claude API integration.
+    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