ruby_llm 1.15.0 → 2.0.0.rc1

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

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Gemini
-      # Streaming methods for the Gemini API implementation
-      module Streaming
-        def stream_url
-          "models/#{@model}:streamGenerateContent?alt=sse"
-        end
-
-        def build_chunk(data)
-          parts = data.dig('candidates', 0, 'content', 'parts') || []
-
-          Chunk.new(
-            role: :assistant,
-            model_id: extract_model_id(data),
-            content: extract_text_content(parts),
-            thinking: Thinking.build(
-              text: extract_thought_content(parts),
-              signature: extract_thought_signature(parts)
-            ),
-            input_tokens: extract_input_tokens(data),
-            output_tokens: extract_output_tokens(data),
-            cached_tokens: data.dig('usageMetadata', 'cachedContentTokenCount'),
-            thinking_tokens: data.dig('usageMetadata', 'thoughtsTokenCount'),
-            tool_calls: extract_tool_calls(data)
-          )
-        end
-
-        private
-
-        def extract_model_id(data)
-          data['modelVersion']
-        end
-
-        def extract_text_content(parts)
-          text_parts = parts.reject { |p| p['thought'] }
-          text = text_parts.filter_map { |p| p['text'] }.join
-          text.empty? ? nil : text
-        end
-
-        def extract_thought_content(parts)
-          thought_parts = parts.select { |p| p['thought'] }
-          thoughts = thought_parts.filter_map { |p| p['text'] }.join
-          thoughts.empty? ? nil : thoughts
-        end
-
-        def extract_thought_signature(parts)
-          parts.each do |part|
-            signature = part['thoughtSignature'] ||
-                        part['thought_signature'] ||
-                        part.dig('functionCall', 'thoughtSignature') ||
-                        part.dig('functionCall', 'thought_signature')
-            return signature if signature
-          end
-
-          nil
-        end
-
-        def extract_content(data)
-          return nil unless data['candidates']&.any?
-
-          candidate = data['candidates'][0]
-          parts = candidate.dig('content', 'parts')
-          return nil unless parts
-
-          text_parts = parts.select { |p| p['text'] }
-          text_parts.map { |p| p['text'] }.join if text_parts.any?
-        end
-
-        def extract_input_tokens(data)
-          prompt_tokens = data.dig('usageMetadata', 'promptTokenCount')
-          return unless prompt_tokens
-
-          [prompt_tokens.to_i - data.dig('usageMetadata', 'cachedContentTokenCount').to_i, 0].max
-        end
-
-        def extract_output_tokens(data)
-          candidates = data.dig('usageMetadata', 'candidatesTokenCount') || 0
-          thoughts = data.dig('usageMetadata', 'thoughtsTokenCount') || 0
-          total = candidates + thoughts
-          total.positive? ? total : nil
-        end
-
-        def parse_streaming_error(data)
-          error_data = JSON.parse(data)
-          [error_data['error']['code'], error_data['error']['message']]
-        rescue JSON::ParserError => e
-          RubyLLM.logger.debug { "Failed to parse streaming error: #{e.message}" }
-          [500, "Failed to parse error: #{data}"]
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/gemini/tools.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Gemini
-      # Tools methods for the Gemini API implementation
-      module Tools
-        def format_tools(tools)
-          return [] if tools.empty?
-
-          [{
-            functionDeclarations: tools.values.map { |tool| function_declaration_for(tool) }
-          }]
-        end
-
-        def format_tool_call(msg) # rubocop:disable Metrics/PerceivedComplexity
-          parts = []
-
-          if msg.content && !(msg.content.respond_to?(:empty?) && msg.content.empty?)
-            formatted_content = Media.format_content(msg.content)
-            parts.concat(formatted_content.is_a?(Array) ? formatted_content : [formatted_content])
-          end
-
-          fallback_signature = msg.thinking&.signature
-          used_fallback = false
-
-          msg.tool_calls.each_value do |tool_call|
-            part = {
-              functionCall: {
-                name: tool_call.name,
-                args: tool_call.arguments
-              }
-            }
-
-            signature = tool_call.thought_signature
-            if signature.nil? && fallback_signature && !used_fallback
-              signature = fallback_signature
-              used_fallback = true
-            end
-            part[:thoughtSignature] = signature if signature
-            parts << part
-          end
-
-          parts
-        end
-
-        def format_tool_result(msg, function_name = nil)
-          function_name ||= msg.tool_call_id
-          content = msg.content
-          content = '(no output)' if content.nil? || (content.respond_to?(:empty?) && content.empty?)
-
-          [{
-            functionResponse: {
-              name: function_name,
-              response: {
-                name: function_name,
-                content: Media.format_content(content)
-              }
-            }
-          }]
-        end
-
-        def extract_tool_calls(data) # rubocop:disable Metrics/PerceivedComplexity
-          return nil unless data
-
-          candidate = data.is_a?(Hash) ? data.dig('candidates', 0) : nil
-          return nil unless candidate
-
-          parts = candidate.dig('content', 'parts')
-          return nil unless parts.is_a?(Array)
-
-          tool_calls = parts.each_with_object({}) do |part, result|
-            function_data = part['functionCall']
-            next unless function_data
-
-            id = SecureRandom.uuid
-            thought_signature = part['thoughtSignature'] || part['thought_signature']
-
-            result[id] = ToolCall.new(
-              id:,
-              name: function_data['name'],
-              arguments: function_data['args'] || {},
-              thought_signature: thought_signature
-            )
-          end
-
-          tool_calls.empty? ? nil : tool_calls
-        end
-
-        private
-
-        def function_declaration_for(tool)
-          parameters_schema = tool.params_schema ||
-                              RubyLLM::Tool::SchemaDefinition.from_parameters(tool.parameters)&.json_schema
-
-          declaration = {
-            name: tool.name,
-            description: tool.description
-          }
-
-          declaration[:parameters] = convert_tool_schema_to_gemini(parameters_schema) if parameters_schema
-
-          return declaration if tool.provider_params.empty?
-
-          RubyLLM::Utils.deep_merge(declaration, tool.provider_params)
-        end
-
-        def convert_tool_schema_to_gemini(schema)
-          return nil unless schema
-
-          schema = RubyLLM::Utils.deep_stringify_keys(schema)
-
-          raise ArgumentError, 'Gemini tool parameters must be objects' unless schema['type'] == 'object'
-
-          {
-            type: 'OBJECT',
-            properties: schema.fetch('properties', {}).transform_values { |property| convert_property(property) },
-            required: (schema['required'] || []).map(&:to_s)
-          }
-        end
-
-        def convert_property(property_schema) # rubocop:disable Metrics/PerceivedComplexity
-          normalized_schema = normalize_any_of_schema(property_schema)
-          working_schema = normalized_schema || property_schema
-
-          type = param_type_for_gemini(working_schema['type'])
-
-          property = {
-            type: type
-          }
-
-          copy_common_attributes(property, property_schema)
-          copy_common_attributes(property, working_schema)
-
-          case type
-          when 'ARRAY'
-            items_schema = working_schema['items'] || property_schema['items'] || { 'type' => 'string' }
-            property[:items] = convert_property(items_schema)
-            copy_tool_attributes(property, working_schema, %w[minItems maxItems])
-            copy_tool_attributes(property, property_schema, %w[minItems maxItems])
-          when 'OBJECT'
-            nested_properties = working_schema.fetch('properties', {}).transform_values do |child|
-              convert_property(child)
-            end
-            property[:properties] = nested_properties
-            required = working_schema['required'] || property_schema['required']
-            property[:required] = required.map(&:to_s) if required
-          end
-
-          property
-        end
-
-        def copy_common_attributes(target, source)
-          copy_tool_attributes(target, source, %w[description enum format nullable maximum minimum multipleOf])
-        end
-
-        def copy_tool_attributes(target, source, attributes)
-          attributes.each do |attribute|
-            value = schema_value(source, attribute)
-            next if value.nil?
-
-            target[attribute.to_sym] = value
-          end
-        end
-
-        def normalize_any_of_schema(schema) # rubocop:disable Metrics/PerceivedComplexity
-          any_of = schema['anyOf'] || schema[:anyOf]
-          return nil unless any_of.is_a?(Array) && any_of.any?
-
-          null_entries, non_null_entries = any_of.partition { |entry| schema_type(entry).to_s == 'null' }
-
-          if non_null_entries.size == 1 && null_entries.any?
-            normalized = RubyLLM::Utils.deep_dup(non_null_entries.first)
-            normalized['nullable'] = true
-            normalized
-          elsif non_null_entries.any?
-            RubyLLM::Utils.deep_dup(non_null_entries.first)
-          else
-            { 'type' => 'string', 'nullable' => true }
-          end
-        end
-
-        def schema_type(schema)
-          schema['type'] || schema[:type]
-        end
-
-        def schema_value(source, attribute) # rubocop:disable Metrics/PerceivedComplexity
-          case attribute
-          when 'multipleOf'
-            source['multipleOf'] || source[:multipleOf] || source['multiple_of'] || source[:multiple_of]
-          when 'minItems'
-            source['minItems'] || source[:minItems] || source['min_items'] || source[:min_items]
-          when 'maxItems'
-            source['maxItems'] || source[:maxItems] || source['max_items'] || source[:max_items]
-          else
-            source[attribute] || source[attribute.to_sym]
-          end
-        end
-
-        def param_type_for_gemini(type)
-          case type.to_s.downcase
-          when 'integer' then 'INTEGER'
-          when 'number', 'float', 'double' then 'NUMBER'
-          when 'boolean' then 'BOOLEAN'
-          when 'array' then 'ARRAY'
-          when 'object' then 'OBJECT'
-          else 'STRING'
-          end
-        end
-
-        def build_tool_config(tool_choice)
-          {
-            functionCallingConfig: {
-              mode: forced_tool_choice?(tool_choice) ? 'any' : tool_choice
-            }.tap do |config|
-              # Use allowedFunctionNames to simulate specific tool choice
-              config[:allowedFunctionNames] = [tool_choice] if specific_tool_choice?(tool_choice)
-            end
-          }
-        end
-
-        def forced_tool_choice?(tool_choice)
-          tool_choice == :required || specific_tool_choice?(tool_choice)
-        end
-
-        def specific_tool_choice?(tool_choice)
-          !%i[auto none required].include?(tool_choice)
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class GPUStack
-      # Determines capabilities for GPUStack models
-      module Capabilities
-        module_function
-
-        def supports_tool_choice?(_model_id)
-          false
-        end
-
-        def supports_tool_parallel_control?(_model_id)
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Ollama
-      # Determines capabilities for Ollama models
-      module Capabilities
-        module_function
-
-        def supports_tool_choice?(_model_id)
-          false
-        end
-
-        def supports_tool_parallel_control?(_model_id)
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class OpenAI
-      # Chat methods of the OpenAI API integration
-      module Chat
-        def completion_url
-          'chat/completions'
-        end
-
-        module_function
-
-        # rubocop:disable Metrics/ParameterLists,Metrics/PerceivedComplexity
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil,
-                           thinking: nil, tool_prefs: nil)
-          tool_prefs ||= {}
-          payload = {
-            model: model.id,
-            messages: format_messages(messages),
-            stream: stream
-          }
-
-          payload[:temperature] = temperature unless temperature.nil?
-          if tools.any?
-            payload[:tools] = tools.map { |_, tool| tool_for(tool) }
-            payload[:tool_choice] = build_tool_choice(tool_prefs[:choice]) unless tool_prefs[:choice].nil?
-            payload[:parallel_tool_calls] = tool_prefs[:calls] == :many unless tool_prefs[:calls].nil?
-          end
-
-          if schema
-            schema_name = schema[:name]
-            schema_def = schema[:schema]
-            strict = schema[:strict]
-
-            payload[:response_format] = {
-              type: 'json_schema',
-              json_schema: {
-                name: schema_name,
-                schema: schema_def,
-                strict: strict
-              }
-            }
-          end
-
-          effort = resolve_effort(thinking)
-          payload[:reasoning_effort] = effort if effort
-
-          payload[:stream_options] = { include_usage: true } if stream
-          payload
-        end
-        # rubocop:enable Metrics/ParameterLists,Metrics/PerceivedComplexity
-
-        def parse_completion_response(response)
-          data = response.body
-          return if data.empty?
-
-          raise Error.new(response, data.dig('error', 'message')) if data.dig('error', 'message')
-
-          message_data = data.dig('choices', 0, 'message')
-          return unless message_data
-
-          usage = data['usage'] || {}
-          thinking_tokens = thinking_tokens(usage)
-          content, thinking_from_blocks = extract_content_and_thinking(message_data['content'])
-          thinking_text = thinking_from_blocks || extract_thinking_text(message_data)
-          thinking_signature = extract_thinking_signature(message_data)
-
-          Message.new(
-            role: :assistant,
-            content: content,
-            thinking: Thinking.build(text: thinking_text, signature: thinking_signature),
-            tool_calls: parse_tool_calls(message_data['tool_calls']),
-            input_tokens: input_tokens(usage),
-            output_tokens: output_tokens(usage),
-            cached_tokens: cache_read_tokens(usage),
-            cache_creation_tokens: cache_write_tokens(usage),
-            thinking_tokens: thinking_tokens,
-            model_id: data['model'],
-            raw: response
-          )
-        end
-
-        def input_tokens(usage)
-          return usage['prompt_cache_miss_tokens'] if usage['prompt_cache_miss_tokens']
-
-          prompt_tokens = usage['prompt_tokens']
-          return unless prompt_tokens
-
-          [prompt_tokens.to_i - cache_read_tokens(usage).to_i - cache_write_tokens(usage).to_i, 0].max
-        end
-
-        def output_tokens(usage)
-          completion_tokens = usage['completion_tokens']
-          return unless completion_tokens
-
-          completion_tokens = completion_tokens.to_i
-          generated_tokens = generated_tokens_from_total(usage)
-          return completion_tokens unless generated_tokens && generated_tokens > completion_tokens
-
-          generated_tokens
-        end
-
-        def generated_tokens_from_total(usage)
-          prompt_tokens = usage['prompt_tokens']
-          total_tokens = usage['total_tokens']
-          return unless prompt_tokens && total_tokens
-
-          [total_tokens.to_i - prompt_tokens.to_i, 0].max
-        end
-
-        def cache_read_tokens(usage)
-          usage.dig('prompt_tokens_details', 'cached_tokens') || usage['prompt_cache_hit_tokens']
-        end
-
-        def cache_write_tokens(usage)
-          usage.dig('prompt_tokens_details', 'cache_write_tokens') || 0
-        end
-
-        def thinking_tokens(usage)
-          usage.dig('completion_tokens_details', 'reasoning_tokens') || usage['reasoning_tokens']
-        end
-
-        def format_messages(messages)
-          messages.map do |msg|
-            {
-              role: format_role(msg.role),
-              content: Media.format_content(msg.content),
-              tool_calls: format_tool_calls(msg.tool_calls),
-              tool_call_id: msg.tool_call_id
-            }.compact.merge(format_thinking(msg))
-          end
-        end
-
-        def format_role(role)
-          case role
-          when :system
-            @config.openai_use_system_role ? 'system' : 'developer'
-          else
-            role.to_s
-          end
-        end
-
-        def resolve_effort(thinking)
-          return nil unless thinking
-
-          thinking.respond_to?(:effort) ? thinking.effort : thinking
-        end
-
-        def format_thinking(msg)
-          return {} unless msg.role == :assistant
-
-          thinking = msg.thinking
-          return {} unless thinking
-
-          payload = {}
-          if thinking.text
-            payload[:reasoning] = thinking.text
-            payload[:reasoning_content] = thinking.text
-          end
-          payload[:reasoning_signature] = thinking.signature if thinking.signature
-          payload
-        end
-
-        def extract_thinking_text(message_data)
-          candidate = message_data['reasoning_content'] || message_data['reasoning'] || message_data['thinking']
-          candidate.is_a?(String) ? candidate : nil
-        end
-
-        def extract_thinking_signature(message_data)
-          candidate = message_data['reasoning_signature'] || message_data['signature']
-          candidate.is_a?(String) ? candidate : nil
-        end
-
-        def extract_content_and_thinking(content)
-          return extract_think_tag_content(content) if content.is_a?(String)
-          return [content, nil] unless content.is_a?(Array)
-
-          text = extract_text_from_blocks(content)
-          thinking = extract_thinking_from_blocks(content)
-
-          [text.empty? ? nil : text, thinking.empty? ? nil : thinking]
-        end
-
-        def extract_text_from_blocks(blocks)
-          blocks.filter_map do |block|
-            block['text'] if block['type'] == 'text' && block['text'].is_a?(String)
-          end.join
-        end
-
-        def extract_thinking_from_blocks(blocks)
-          blocks.filter_map do |block|
-            next unless block['type'] == 'thinking'
-
-            extract_thinking_text_from_block(block)
-          end.join
-        end
-
-        def extract_thinking_text_from_block(block)
-          thinking_block = block['thinking']
-          return thinking_block if thinking_block.is_a?(String)
-
-          if thinking_block.is_a?(Array)
-            return thinking_block.filter_map { |item| item['text'] if item['type'] == 'text' }.join
-          end
-
-          block['text'] if block['text'].is_a?(String)
-        end
-
-        def extract_think_tag_content(text)
-          return [text, nil] unless text.include?('<think>')
-
-          thinking = text.scan(%r{<think>(.*?)</think>}m).join
-          content = text.gsub(%r{<think>.*?</think>}m, '').strip
-
-          [content.empty? ? nil : content, thinking.empty? ? nil : thinking]
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class OpenAI
-      # Embeddings methods of the OpenAI API integration
-      module Embeddings
-        module_function
-
-        def embedding_url(...)
-          'embeddings'
-        end
-
-        def render_embedding_payload(text, model:, dimensions:)
-          {
-            model: model,
-            input: text,
-            dimensions: dimensions
-          }.compact
-        end
-
-        def parse_embedding_response(response, model:, text:)
-          data = response.body
-          input_tokens = data.dig('usage', 'prompt_tokens') || 0
-          vectors = data['data'].map { |d| d['embedding'] }
-          vectors = vectors.first if vectors.length == 1 && !text.is_a?(Array)
-
-          Embedding.new(vectors:, model:, input_tokens:)
-        end
-      end
-    end
-  end
-end