ruby_llm 1.16.0 → 2.0.0.rc2

data/lib/ruby_llm/model_registry.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  # Sources for model registry data.
-  module ModelRegistry
-    # Reads model registry data from the configured JSON file.
-    class JsonSource
-      def initialize(file = nil)
-        @file = file
-      end
-
-      def read
-        Models.read_from_json(@file || RubyLLM.config.model_registry_file)
-      end
-    end
-
-    # Reads model registry data from the configured Active Record model class.
-    class ActiveRecordSource
-      def read
-        model_class = resolve_model_class
-        return [] unless model_class.respond_to?(:table_exists?) && model_class.table_exists?
-
-        model_class.all.map(&:to_llm)
-      rescue StandardError => e
-        RubyLLM.logger.debug { "Failed to load models from database: #{e.message}, falling back to JSON" }
-        []
-      end
-
-      private
-
-      def resolve_model_class
-        model_class = RubyLLM.config.model_registry_class
-        return model_class unless model_class.is_a?(String)
-
-        model_class.split('::').inject(Object) { |scope, name| scope.const_get(name) }
-      end
-    end
-  end
-end

data/lib/ruby_llm/models_schema.json

@@ -1,171 +0,0 @@
-{
-  "title": "RubyLLM Models Schema",
-  "description": "Schema for validating the structure of models.json",
-  "type": "array",
-  "items": {
-    "type": "object",
-    "required": ["id", "name", "provider", "context_window", "max_output_tokens"],
-    "properties": {
-      "id": {
-        "type": "string",
-        "description": "Unique identifier for the model"
-      },
-      "name": {
-        "type": "string",
-        "description": "Display name of the model"
-      },
-      "provider": {
-        "type": "string",
-        "description": "Provider of the model (e.g., openai, anthropic, mistral)"
-      },
-      "family": {
-        "type": ["string", "null"],
-        "description": "Model family (e.g., gpt-4, claude-3)"
-      },
-      "created_at": {
-        "type": ["null", {"type": "string", "format": "date-time"}],
-        "description": "Creation date of the model"
-      },
-      "context_window": {
-        "type": ["null", {"type": "integer", "minimum": 0}],
-        "description": "Maximum context window size"
-      },
-      "max_output_tokens": {
-        "type": ["null", {"type": "integer", "minimum": 0}],
-        "description": "Maximum output tokens"
-      },
-      "knowledge_cutoff": {
-        "type": ["null", {"type": "string", "format": "date"}],
-        "description": "Knowledge cutoff date"
-      },
-      "modalities": {
-        "type": "object",
-        "required": ["input", "output"],
-        "properties": {
-          "input": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["text", "image", "audio", "pdf", "video", "file"]
-            },
-            "uniqueItems": true,
-            "description": "Supported input modalities"
-          },
-          "output": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["text", "image", "audio", "video", "embeddings", "moderation"]
-            },
-            "uniqueItems": true,
-            "description": "Supported output modalities"
-          }
-        }
-      },
-      "capabilities": {
-        "type": "array",
-        "items": {
-          "type": "string",
-          "enum": [
-            "streaming", "function_calling", "structured_output", "predicted_outputs",
-            "distillation", "fine_tuning", "batch", "realtime", "image_generation",
-            "speech_generation", "transcription", "translation", "citations", "reasoning",
-            "caching", "moderation", "json_mode", "vision"
-          ]
-        },
-        "uniqueItems": true,
-        "description": "Model capabilities"
-      },
-      "pricing": {
-        "type": "object",
-        "properties": {
-          "text_tokens": {
-            "type": "object",
-            "required": ["standard"],
-            "properties": {
-              "standard": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0},
-                  "cache_read_input_per_million": {"type": "number", "minimum": 0},
-                  "cache_write_input_per_million": {"type": "number", "minimum": 0},
-                  "cached_input_per_million": {"type": "number", "minimum": 0},
-                  "cache_creation_input_per_million": {"type": "number", "minimum": 0},
-                  "output_per_million": {"type": "number", "minimum": 0},
-                  "reasoning_output_per_million": {"type": "number", "minimum": 0}
-                }
-              },
-              "batch": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0},
-                  "output_per_million": {"type": "number", "minimum": 0}
-                }
-              }
-            }
-          },
-          "images": {
-            "type": "object",
-            "properties": {
-              "standard": {
-                "type": "object",
-                "properties": {
-                  "input": {"type": "number", "minimum": 0},
-                  "output": {"type": "number", "minimum": 0}
-                }
-              },
-              "batch": {
-                "type": "object",
-                "properties": {
-                  "input": {"type": "number", "minimum": 0},
-                  "output": {"type": "number", "minimum": 0}
-                }
-              }
-            }
-          },
-          "audio_tokens": {
-            "type": "object",
-            "properties": {
-              "standard": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0},
-                  "output_per_million": {"type": "number", "minimum": 0}
-                }
-              },
-              "batch": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0},
-                  "output_per_million": {"type": "number", "minimum": 0}
-                }
-              }
-            }
-          },
-          "embeddings": {
-            "type": "object",
-            "properties": {
-              "standard": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0}
-                }
-              },
-              "batch": {
-                "type": "object",
-                "properties": {
-                  "input_per_million": {"type": "number", "minimum": 0}
-                }
-              }
-            }
-          }
-        },
-        "description": "Pricing information for the model"
-      },
-      "metadata": {
-        "type": "object",
-        "description": "Additional metadata about the model"
-      }
-    }
-  }
-}

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

@@ -1,291 +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?
-
-          # Anthropic's `system` parameter accepts an array of text content blocks
-          # (each optionally with cache_control); each :system message becomes its
-          # own block in the resulting array.
-          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
-          }
-
-          add_thinking_fields(payload, thinking, model)
-
-          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] = payload.fetch(:output_config, {}).merge(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)
-          append_formatted_content(content_blocks, 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 add_thinking_fields(payload, thinking, model)
-          thinking_payload = build_thinking_payload(thinking, model)
-          return unless thinking_payload
-
-          payload[:thinking] = thinking_payload[:thinking] if thinking_payload[:thinking]
-          return unless thinking_payload[:output_config]
-
-          payload[:output_config] = payload.fetch(:output_config, {}).merge(thinking_payload[:output_config])
-        end
-
-        def build_thinking_payload(thinking, model)
-          return nil unless thinking&.enabled?
-
-          effort = resolve_effort(thinking)
-          return nil if effort == 'none'
-
-          budget = resolve_budget(thinking)
-          if budget
-            return enabled_thinking_payload(budget) if model.reasoning_option('budget_tokens')
-
-            raise ArgumentError, "Anthropic thinking budget is not supported for #{model.id}"
-          end
-
-          raise ArgumentError, 'Anthropic adaptive thinking requires an effort' if effort.nil?
-          return adaptive_thinking_payload(effort) if model.reasoning_option('effort')
-
-          raise ArgumentError, "Anthropic thinking effort is not supported for #{model.id}"
-        end
-
-        def enabled_thinking_payload(budget)
-          {
-            thinking: {
-              type: 'enabled',
-              budget_tokens: budget
-            }
-          }
-        end
-
-        def adaptive_thinking_payload(effort)
-          {
-            thinking: { type: 'adaptive' },
-            output_config: { effort: effort }
-          }
-        end
-
-        def resolve_effort(thinking)
-          effort = thinking.respond_to?(:effort) ? thinking.effort : nil
-          effort = effort.to_s if effort
-          effort.nil? || effort.empty? ? nil : effort
-        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