ruby_llm 1.16.0 → 2.0.0.rc2

data/lib/ruby_llm/providers/openai/images.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'stringio'
-
-module RubyLLM
-  module Providers
-    class OpenAI
-      # Image generation methods for the OpenAI API integration
-      module Images
-        module_function
-
-        def images_url(with: nil, mask: nil)
-          editing?(with, mask) ? 'images/edits' : 'images/generations'
-        end
-
-        def render_image_payload(prompt, model:, size:, with: nil, mask: nil, params: {}) # rubocop:disable Metrics/ParameterLists
-          return render_edit_payload(prompt, model:, with:, mask:, params:) if editing?(with, mask)
-
-          {
-            model: model,
-            prompt: prompt,
-            n: 1,
-            size: size
-          }.merge(params)
-        end
-
-        def parse_image_response(response, model:)
-          data = response.body
-          image_data = Array(data['data']).first
-
-          raise Error.new(nil, 'Unexpected response format from OpenAI image API') unless image_data
-
-          Image.new(
-            url: image_data['url'],
-            mime_type: 'image/png', # DALL-E typically returns PNGs
-            revised_prompt: image_data['revised_prompt'],
-            model_id: model,
-            data: image_data['b64_json'],
-            usage: data['usage'] || {}
-          )
-        end
-
-        def validate_paint_inputs!(with:, mask:)
-          return unless editing?(with, mask)
-
-          raise ArgumentError, 'with: is required when mask: is provided' if mask && !attachments?(with)
-        end
-
-        def render_edit_payload(prompt, model:, with:, mask:, params:)
-          payload = params.merge(
-            model: model,
-            prompt: prompt,
-            image: build_upload_parts(with),
-            n: 1
-          )
-          payload[:mask] = build_upload_part(mask) if mask
-          payload
-        end
-
-        def build_upload_parts(sources)
-          Array(sources).filter_map do |source|
-            next if blank_attachment?(source)
-
-            build_upload_part(source)
-          end
-        end
-
-        def build_upload_part(source)
-          attachment = Attachment.new(source)
-          raise UnsupportedAttachmentError, attachment.mime_type unless attachment.image?
-
-          Faraday::UploadIO.new(StringIO.new(attachment.content), attachment.mime_type, attachment.filename)
-        end
-
-        def editing?(with, mask)
-          attachments?(with) || !mask.nil?
-        end
-
-        def attachments?(value)
-          Array(value).any? { |item| !blank_attachment?(item) }
-        end
-
-        def blank_attachment?(value)
-          value.nil? || (value.is_a?(String) && value.strip.empty?)
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/openai/moderation.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class OpenAI
-      # Moderation methods of the OpenAI API integration
-      module Moderation
-        module_function
-
-        def moderation_url
-          'moderations'
-        end
-
-        def render_moderation_payload(input, model:)
-          {
-            model: model,
-            input: input
-          }
-        end
-
-        def parse_moderation_response(response, model:)
-          data = response.body
-          raise Error.new(response, data.dig('error', 'message')) if data.dig('error', 'message')
-
-          RubyLLM::Moderation.new(
-            id: data['id'],
-            model: model,
-            results: data['results'] || []
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module RubyLLM
-  module Providers
-    class OpenAI
-      # Streaming methods of the OpenAI API integration
-      module Streaming
-        module_function
-
-        def stream_url
-          completion_url
-        end
-
-        def build_chunk(data)
-          usage = data['usage'] || {}
-          delta = data.dig('choices', 0, 'delta') || {}
-          content_source = delta['content'] || data.dig('choices', 0, 'message', 'content')
-          content, thinking_from_blocks = OpenAI::Chat.extract_content_and_thinking(content_source)
-
-          Chunk.new(
-            role: :assistant,
-            model_id: data['model'],
-            content: content,
-            thinking: Thinking.build(
-              text: thinking_from_blocks || delta['reasoning_content'] || delta['reasoning'],
-              signature: delta['reasoning_signature']
-            ),
-            tool_calls: parse_tool_calls(delta['tool_calls'], parse_arguments: false),
-            input_tokens: OpenAI::Chat.input_tokens(usage),
-            output_tokens: OpenAI::Chat.output_tokens(usage),
-            cached_tokens: OpenAI::Chat.cache_read_tokens(usage),
-            cache_creation_tokens: OpenAI::Chat.cache_write_tokens(usage),
-            thinking_tokens: OpenAI::Chat.thinking_tokens(usage)
-          )
-        end
-
-        def parse_streaming_error(data)
-          error_data = JSON.parse(data)
-          return unless error_data['error']
-
-          case error_data.dig('error', 'type')
-          when 'server_error'
-            [500, error_data['error']['message']]
-          when 'rate_limit_exceeded', 'insufficient_quota'
-            [429, error_data['error']['message']]
-          else
-            [400, error_data['error']['message']]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/openai/temperature.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class OpenAI
-      # Normalizes temperature for OpenAI models with provider-specific requirements.
-      module Temperature
-        module_function
-
-        def normalize(temperature, model_id)
-          if model_id.match?(/^(o\d|gpt-5)/) && !temperature.nil? && !temperature_close_to_one?(temperature)
-            RubyLLM.logger.debug { "Model #{model_id} requires temperature=1.0, setting that instead." }
-            1.0
-          elsif model_id.include?('-search')
-            RubyLLM.logger.debug { "Model #{model_id} does not accept temperature parameter, removing" }
-            nil
-          else
-            temperature
-          end
-        end
-
-        def temperature_close_to_one?(temperature)
-          (temperature.to_f - 1.0).abs <= Float::EPSILON
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/openai/transcription.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class OpenAI
-      # Audio transcription methods for the OpenAI API integration
-      module Transcription
-        module_function
-
-        def transcription_url
-          'audio/transcriptions'
-        end
-
-        def render_transcription_payload(file_part, model:, language:, **options)
-          {
-            model: model,
-            file: file_part,
-            language: language,
-            chunking_strategy: (options[:chunking_strategy] || 'auto' if supports_chunking_strategy?(model, options)),
-            response_format: response_format_for(model, options),
-            prompt: options[:prompt],
-            temperature: options[:temperature],
-            timestamp_granularities: options[:timestamp_granularities],
-            known_speaker_names: options[:speaker_names],
-            known_speaker_references: encode_speaker_references(options[:speaker_references])
-          }.compact
-        end
-
-        def encode_speaker_references(references)
-          return nil unless references
-
-          references.map do |ref|
-            Attachment.new(ref).for_llm
-          end
-        end
-
-        def response_format_for(model, options)
-          return options[:response_format] if options.key?(:response_format)
-
-          'diarized_json' if model.include?('diarize')
-        end
-
-        def supports_chunking_strategy?(model, options)
-          return false if model.start_with?('whisper')
-          return true if options.key?(:chunking_strategy)
-
-          model.include?('diarize')
-        end
-
-        def parse_transcription_response(response, model:)
-          data = response.body
-
-          return RubyLLM::Transcription.new(text: data, model: model) if data.is_a?(String)
-
-          usage = data['usage'] || {}
-
-          RubyLLM::Transcription.new(
-            text: data['text'],
-            model: model,
-            language: data['language'],
-            duration: data['duration'],
-            segments: data['segments'],
-            words: data['words'],
-            input_tokens: usage['input_tokens'] || usage['prompt_tokens'],
-            output_tokens: usage['output_tokens'] || usage['completion_tokens']
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Perplexity
-      # Provider-level capability checks and narrow registry fallbacks.
-      module Capabilities
-        module_function
-
-        PRICES = {
-          sonar: { input: 1.0, output: 1.0 },
-          sonar_pro: { input: 3.0, output: 15.0 },
-          sonar_reasoning: { input: 1.0, output: 5.0 },
-          sonar_reasoning_pro: { input: 2.0, output: 8.0 },
-          sonar_deep_research: {
-            input: 2.0,
-            output: 8.0,
-            reasoning_output: 3.0
-          }
-        }.freeze
-
-        def supports_tool_choice?(_model_id)
-          false
-        end
-
-        def supports_tool_parallel_control?(_model_id)
-          false
-        end
-
-        def context_window_for(model_id)
-          model_id.match?(/sonar-pro/) ? 200_000 : 128_000
-        end
-
-        def max_tokens_for(model_id)
-          model_id.match?(/sonar-(?:pro|reasoning-pro)/) ? 8_192 : 4_096
-        end
-
-        def critical_capabilities_for(model_id)
-          capabilities = []
-          capabilities << 'vision' if model_id.match?(/sonar(?:-pro|-reasoning(?:-pro)?)?$/)
-          capabilities << 'reasoning' if model_id.match?(/reasoning|deep-research/)
-          capabilities
-        end
-
-        def pricing_for(model_id)
-          prices = PRICES.fetch(model_family(model_id), { input: 1.0, output: 1.0 })
-
-          standard = {
-            input_per_million: prices[:input],
-            output_per_million: prices[:output]
-          }
-          standard[:reasoning_output_per_million] = prices[:reasoning_output] if prices[:reasoning_output]
-
-          { text_tokens: { standard: standard } }
-        end
-
-        def model_family(model_id)
-          case model_id
-          when 'sonar' then :sonar
-          when 'sonar-pro' then :sonar_pro
-          when 'sonar-reasoning' then :sonar_reasoning
-          when 'sonar-reasoning-pro' then :sonar_reasoning_pro
-          when 'sonar-deep-research' then :sonar_deep_research
-          else :unknown
-          end
-        end
-
-        module_function :context_window_for, :max_tokens_for, :critical_capabilities_for, :pricing_for, :model_family
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class VertexAI
-      # Chat methods for the Vertex AI implementation
-      module Chat
-        def completion_url
-          "projects/#{@config.vertexai_project_id}/locations/#{@config.vertexai_location}/publishers/google/models/#{@model}:generateContent" # rubocop:disable Layout/LineLength
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class VertexAI
-      # Streaming methods for the Vertex AI implementation
-      module Streaming
-        def stream_url
-          "projects/#{@config.vertexai_project_id}/locations/#{@config.vertexai_location}/publishers/google/models/#{@model}:streamGenerateContent?alt=sse" # rubocop:disable Layout/LineLength
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/stream_accumulator.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'securerandom'
-
-module RubyLLM
-  # Assembles streaming responses from LLMs into complete messages.
-  class StreamAccumulator
-    attr_reader :content, :model_id, :tool_calls
-
-    def initialize
-      @content = +''
-      @thinking_text = +''
-      @thinking_signature = nil
-      @tool_calls = {}
-      @input_tokens = nil
-      @output_tokens = nil
-      @cached_tokens = nil
-      @cache_creation_tokens = nil
-      @thinking_tokens = nil
-      @inside_think_tag = false
-      @pending_think_tag = +''
-      @latest_tool_call_id = nil
-      @tool_call_ids_by_index = {}
-    end
-
-    def add(chunk)
-      RubyLLM.logger.debug { chunk.inspect } if RubyLLM.config.log_stream_debug
-      @model_id ||= chunk.model_id
-
-      handle_chunk_content(chunk)
-      append_thinking_from_chunk(chunk)
-      count_tokens chunk
-      RubyLLM.logger.debug { inspect } if RubyLLM.config.log_stream_debug
-    end
-
-    def to_message(response)
-      Message.new(
-        role: :assistant,
-        content: content.empty? ? nil : content,
-        thinking: Thinking.build(
-          text: @thinking_text.empty? ? nil : @thinking_text,
-          signature: @thinking_signature
-        ),
-        tokens: Tokens.build(
-          input: @input_tokens,
-          output: @output_tokens,
-          cached: @cached_tokens,
-          cache_creation: @cache_creation_tokens,
-          thinking: @thinking_tokens
-        ),
-        model_id: model_id,
-        tool_calls: tool_calls_from_stream,
-        raw: response
-      )
-    end
-
-    private
-
-    def tool_calls_from_stream
-      tool_calls.transform_values do |tc|
-        arguments = if tc.arguments.is_a?(String) && !tc.arguments.empty?
-                      JSON.parse(tc.arguments)
-                    elsif tc.arguments.is_a?(String)
-                      {}
-                    else
-                      tc.arguments
-                    end
-
-        ToolCall.new(
-          id: tc.id,
-          name: tc.name,
-          arguments: arguments,
-          thought_signature: tc.thought_signature
-        )
-      end
-    end
-
-    def accumulate_tool_calls(new_tool_calls)
-      RubyLLM.logger.debug { "Accumulating tool calls: #{new_tool_calls}" } if RubyLLM.config.log_stream_debug
-      new_tool_calls.each do |stream_key, tool_call|
-        if tool_call.id
-          start_tool_call(stream_key, tool_call)
-        else
-          append_tool_call_fragment(stream_key, tool_call)
-        end
-      end
-    end
-
-    def start_tool_call(stream_key, tool_call)
-      tool_call_id = tool_call.id.empty? ? SecureRandom.uuid : tool_call.id
-      tool_call_key = tool_call.id
-
-      @tool_calls[tool_call_key] = ToolCall.new(
-        id: tool_call_id,
-        name: tool_call.name,
-        arguments: initial_tool_call_arguments(tool_call),
-        thought_signature: tool_call.thought_signature
-      )
-      @tool_call_ids_by_index[stream_key] = tool_call_key unless stream_key.nil?
-      @latest_tool_call_id = tool_call_key
-    end
-
-    def initial_tool_call_arguments(tool_call)
-      arguments = tool_call.arguments
-      return +'' if arguments.nil? || (arguments.respond_to?(:empty?) && arguments.empty?)
-
-      arguments
-    end
-
-    def append_tool_call_fragment(stream_key, tool_call)
-      existing = find_tool_call(stream_key)
-      return unless existing
-
-      fragment = tool_call.arguments
-      fragment = '' if fragment.nil?
-      existing.arguments << fragment
-      return unless tool_call.thought_signature && existing.thought_signature.nil?
-
-      existing.thought_signature = tool_call.thought_signature
-    end
-
-    def find_tool_call(stream_key)
-      return @tool_calls[@latest_tool_call_id] if stream_key.nil?
-
-      @tool_calls[@tool_call_ids_by_index[stream_key]] || @tool_calls[stream_key]
-    end
-
-    def count_tokens(chunk)
-      @input_tokens = chunk.input_tokens if chunk.input_tokens
-      @output_tokens = chunk.output_tokens if chunk.output_tokens
-      @cached_tokens = chunk.cached_tokens if chunk.cached_tokens
-      @cache_creation_tokens = chunk.cache_creation_tokens if chunk.cache_creation_tokens
-      @thinking_tokens = chunk.thinking_tokens if chunk.thinking_tokens
-    end
-
-    def handle_chunk_content(chunk)
-      return accumulate_tool_calls(chunk.tool_calls) if chunk.tool_call?
-
-      content_text = chunk.content || ''
-      if content_text.is_a?(String)
-        append_text_with_thinking(content_text)
-      else
-        @content << content_text.to_s
-      end
-    end
-
-    def append_text_with_thinking(text)
-      content_chunk, thinking_chunk = extract_think_tags(text)
-      @content << content_chunk
-      @thinking_text << thinking_chunk if thinking_chunk
-    end
-
-    def append_thinking_from_chunk(chunk)
-      thinking = chunk.thinking
-      return unless thinking
-
-      @thinking_text << thinking.text.to_s if thinking.text
-      @thinking_signature ||= thinking.signature # rubocop:disable Naming/MemoizedInstanceVariableName
-    end
-
-    def extract_think_tags(text)
-      start_tag = '<think>'
-      end_tag = '</think>'
-      remaining = @pending_think_tag + text
-      @pending_think_tag = +''
-
-      output = +''
-      thinking = +''
-
-      until remaining.empty?
-        remaining = if @inside_think_tag
-                      consume_think_content(remaining, end_tag, thinking)
-                    else
-                      consume_non_think_content(remaining, start_tag, output)
-                    end
-      end
-
-      [output, thinking.empty? ? nil : thinking]
-    end
-
-    def consume_think_content(remaining, end_tag, thinking)
-      end_index = remaining.index(end_tag)
-      if end_index
-        thinking << remaining.slice(0, end_index)
-        @inside_think_tag = false
-        remaining.slice((end_index + end_tag.length)..) || +''
-      else
-        suffix_len = longest_suffix_prefix(remaining, end_tag)
-        thinking << remaining.slice(0, remaining.length - suffix_len)
-        @pending_think_tag = remaining.slice(-suffix_len, suffix_len)
-        +''
-      end
-    end
-
-    def consume_non_think_content(remaining, start_tag, output)
-      start_index = remaining.index(start_tag)
-      if start_index
-        output << remaining.slice(0, start_index)
-        @inside_think_tag = true
-        remaining.slice((start_index + start_tag.length)..) || +''
-      else
-        suffix_len = longest_suffix_prefix(remaining, start_tag)
-        output << remaining.slice(0, remaining.length - suffix_len)
-        @pending_think_tag = remaining.slice(-suffix_len, suffix_len)
-        +''
-      end
-    end
-
-    def longest_suffix_prefix(text, tag)
-      max = [text.length, tag.length - 1].min
-      max.downto(1) do |len|
-        return len if text.end_with?(tag[0, len])
-      end
-      0
-    end
-  end
-end