ruby_llm 1.15.0 → 2.0.0.rc1

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

@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Anthropic
-      # Chat methods for the Anthropic API implementation
-      module Chat
-        module_function
-
-        def completion_url
-          'v1/messages'
-        end
-
-        # rubocop:disable Metrics/ParameterLists
-        def render_payload(messages, tools:, temperature:, model:, stream: false,
-                           schema: nil, thinking: nil, tool_prefs: nil)
-          tool_prefs ||= {}
-          system_messages, chat_messages = separate_messages(messages)
-          system_content = build_system_content(system_messages)
-
-          build_base_payload(chat_messages, model, stream, thinking).tap do |payload|
-            add_optional_fields(payload, system_content:, tools:, tool_prefs:, temperature:, schema:)
-          end
-        end
-        # rubocop:enable Metrics/ParameterLists
-
-        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, thinking)
-          payload = {
-            model: model.id,
-            messages: chat_messages.map { |msg| format_message(msg, thinking: thinking) },
-            stream: stream,
-            max_tokens: model.max_tokens || 4096
-          }
-
-          thinking_payload = build_thinking_payload(thinking)
-          payload[:thinking] = thinking_payload if thinking_payload
-
-          payload
-        end
-
-        def add_optional_fields(payload, system_content:, tools:, tool_prefs:, temperature:, schema: nil) # rubocop:disable Metrics/ParameterLists
-          if tools.any?
-            payload[:tools] = tools.values.map { |t| Tools.function_for(t) }
-            unless tool_prefs[:choice].nil? && tool_prefs[:calls].nil?
-              payload[:tool_choice] = Tools.build_tool_choice(tool_prefs)
-            end
-          end
-          payload[:system] = system_content unless system_content.empty?
-          payload[:temperature] = temperature unless temperature.nil?
-          payload[:output_config] = build_output_config(schema) if schema
-        end
-
-        def build_output_config(schema)
-          normalized = RubyLLM::Utils.deep_dup(schema[:schema])
-          normalized.delete(:strict)
-          normalized.delete('strict')
-          { format: { type: 'json_schema', schema: normalized } }
-        end
-
-        def parse_completion_response(response)
-          data = response.body
-          content_blocks = data['content'] || []
-
-          text_content = extract_text_content(content_blocks)
-          thinking_content = extract_thinking_content(content_blocks)
-          thinking_signature = extract_thinking_signature(content_blocks)
-          tool_use_blocks = Tools.find_tool_uses(content_blocks)
-
-          build_message(data, text_content, thinking_content, thinking_signature, 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 extract_thinking_content(blocks)
-          thinking_blocks = blocks.select { |c| c['type'] == 'thinking' }
-          thoughts = thinking_blocks.map { |c| c['thinking'] || c['text'] }.join
-          thoughts.empty? ? nil : thoughts
-        end
-
-        def extract_thinking_signature(blocks)
-          thinking_block = blocks.find { |c| c['type'] == 'thinking' } ||
-                           blocks.find { |c| c['type'] == 'redacted_thinking' }
-          thinking_block&.dig('signature') || thinking_block&.dig('data')
-        end
-
-        def build_message(data, content, thinking, thinking_signature, tool_use_blocks, response) # rubocop:disable Metrics/ParameterLists
-          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
-          thinking_tokens = usage.dig('output_tokens_details', 'thinking_tokens') ||
-                            usage.dig('output_tokens_details', 'reasoning_tokens') ||
-                            usage['thinking_tokens'] ||
-                            usage['reasoning_tokens']
-
-          Message.new(
-            role: :assistant,
-            content: content,
-            thinking: Thinking.build(text: thinking, signature: thinking_signature),
-            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,
-            thinking_tokens: thinking_tokens,
-            model_id: data['model'],
-            raw: response
-          )
-        end
-
-        def format_message(msg, thinking: nil)
-          thinking_enabled = thinking&.enabled?
-
-          if msg.tool_call?
-            format_tool_call_with_thinking(msg, thinking_enabled)
-          elsif msg.tool_result?
-            Tools.format_tool_result(msg)
-          else
-            format_basic_message_with_thinking(msg, thinking_enabled)
-          end
-        end
-
-        def format_basic_message_with_thinking(msg, thinking_enabled)
-          content_blocks = []
-
-          if msg.role == :assistant && thinking_enabled
-            thinking_block = build_thinking_block(msg.thinking)
-            content_blocks << thinking_block if thinking_block
-          end
-
-          append_formatted_content(content_blocks, msg.content)
-
-          {
-            role: convert_role(msg.role),
-            content: content_blocks
-          }
-        end
-
-        def format_tool_call_with_thinking(msg, thinking_enabled)
-          if msg.content.is_a?(RubyLLM::Content::Raw)
-            content_blocks = msg.content.value
-            content_blocks = [content_blocks] unless content_blocks.is_a?(Array)
-            content_blocks = prepend_thinking_block(content_blocks, msg, thinking_enabled)
-
-            return { role: 'assistant', content: content_blocks }
-          end
-
-          content_blocks = prepend_thinking_block([], msg, thinking_enabled)
-          content_blocks << Media.format_text(msg.content) unless msg.content.nil? || msg.content.empty?
-
-          msg.tool_calls.each_value do |tool_call|
-            content_blocks << {
-              type: 'tool_use',
-              id: tool_call.id,
-              name: tool_call.name,
-              input: tool_call.arguments
-            }
-          end
-
-          {
-            role: 'assistant',
-            content: content_blocks
-          }
-        end
-
-        def prepend_thinking_block(content_blocks, msg, thinking_enabled)
-          return content_blocks unless thinking_enabled
-
-          thinking_block = build_thinking_block(msg.thinking)
-          content_blocks.unshift(thinking_block) if thinking_block
-
-          content_blocks
-        end
-
-        def build_thinking_block(thinking)
-          return nil unless thinking
-
-          if thinking.text
-            {
-              type: 'thinking',
-              thinking: thinking.text,
-              signature: thinking.signature
-            }.compact
-          elsif thinking.signature
-            {
-              type: 'redacted_thinking',
-              data: thinking.signature
-            }
-          end
-        end
-
-        def append_formatted_content(content_blocks, content)
-          formatted_content = Media.format_content(content)
-          if formatted_content.is_a?(Array)
-            content_blocks.concat(formatted_content)
-          else
-            content_blocks << formatted_content
-          end
-        end
-
-        def convert_role(role)
-          case role
-          when :tool, :user then 'user'
-          else 'assistant'
-          end
-        end
-
-        def build_thinking_payload(thinking)
-          return nil unless thinking&.enabled?
-
-          budget = resolve_budget(thinking)
-          raise ArgumentError, 'Anthropic thinking requires a budget' if budget.nil?
-
-          {
-            type: 'enabled',
-            budget_tokens: budget
-          }
-        end
-
-        def resolve_budget(thinking)
-          budget = thinking.respond_to?(:budget) ? thinking.budget : thinking
-          budget.is_a?(Integer) ? budget : nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,92 +0,0 @@
-# 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.to_s
-              }
-            }
-          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.to_s
-              }
-            }
-          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

@@ -1,57 +0,0 @@
-# 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'] || model_id,
-              provider: slug,
-              created_at: Time.parse(model_data['created_at']),
-              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

@@ -1,69 +0,0 @@
-# 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)
-          delta_type = data.dig('delta', 'type')
-
-          Chunk.new(
-            role: :assistant,
-            model_id: extract_model_id(data),
-            content: extract_content_delta(data, delta_type),
-            thinking: Thinking.build(
-              text: extract_thinking_delta(data, delta_type),
-              signature: extract_signature_delta(data, delta_type)
-            ),
-            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 extract_content_delta(data, delta_type)
-          return data.dig('delta', 'text') if delta_type == 'text_delta'
-
-          nil
-        end
-
-        def extract_thinking_delta(data, delta_type)
-          return data.dig('delta', 'thinking') if delta_type == 'thinking_delta'
-
-          nil
-        end
-
-        def extract_signature_delta(data, delta_type)
-          return data.dig('delta', 'signature') if delta_type == 'signature_delta'
-
-          nil
-        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