ruby_llm 1.16.0 → 2.0.0.rc2

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

@@ -5,11 +5,9 @@ module RubyLLM
     class OpenRouter
       # Streaming methods of the OpenRouter API integration
       module Streaming
-        module_function
+        ACCUMULATED_REASONING_KEYS = %w[text data summary].freeze
 
-        def stream_url
-          completion_url
-        end
+        module_function
 
         def build_chunk(data)
           usage = data['usage'] || {}
@@ -17,55 +15,50 @@ module RubyLLM
 
           Chunk.new(
             role: :assistant,
-            model_id: data['model'],
+            model: data['model'],
             content: delta['content'],
             thinking: Thinking.build(
               text: extract_thinking_text(delta),
               signature: extract_thinking_signature(delta)
             ),
-            tool_calls: OpenAI::Tools.parse_tool_calls(delta['tool_calls'], parse_arguments: false),
-            input_tokens: OpenRouter::Chat.input_tokens(usage),
-            output_tokens: OpenRouter::Chat.output_tokens(usage),
-            cached_tokens: OpenRouter::Chat.cache_read_tokens(usage),
-            cache_creation_tokens: OpenRouter::Chat.cache_write_tokens(usage),
-            thinking_tokens: OpenRouter::Chat.thinking_tokens(usage)
+            raw_reasoning: accumulate_raw_reasoning(delta['reasoning_details']),
+            tool_calls: parse_tool_calls(delta['tool_calls'], parse_arguments: false, stream_keys: true),
+            input_tokens: input_tokens(usage),
+            output_tokens: output_tokens(usage),
+            cache_read_tokens: cache_read_tokens(usage),
+            cache_write_tokens: cache_write_tokens(usage),
+            thinking_tokens: thinking_tokens(usage),
+            reported_cost: reported_cost(usage),
+            finish_reason: normalize_finish_reason(data.dig('choices', 0, 'finish_reason'))
           )
         end
 
-        def parse_streaming_error(data)
-          OpenAI::Streaming.parse_streaming_error(data)
-        end
+        def accumulate_raw_reasoning(details)
+          return @raw_reasoning unless details.is_a?(Array) && !details.empty?
 
-        def extract_thinking_text(delta)
-          candidate = delta['reasoning']
-          return candidate if candidate.is_a?(String)
+          @raw_reasoning ||= []
+          details.each { |detail| merge_reasoning_detail(detail) }
+          @raw_reasoning
+        end
 
-          details = delta['reasoning_details']
-          return nil unless details.is_a?(Array)
+        def merge_reasoning_detail(detail)
+          target = reasoning_detail_target(detail)
+          return @raw_reasoning << detail.dup unless target
 
-          text = details.filter_map do |detail|
-            case detail['type']
-            when 'reasoning.text'
-              detail['text']
-            when 'reasoning.summary'
-              detail['summary']
+          detail.each do |key, value|
+            if value.is_a?(String) && target[key].is_a?(String) && ACCUMULATED_REASONING_KEYS.include?(key)
+              target[key] += value
+            elsif target[key].nil?
+              target[key] = value
             end
-          end.join
-
-          text.empty? ? nil : text
+          end
         end
 
-        def extract_thinking_signature(delta)
-          details = delta['reasoning_details']
-          return nil unless details.is_a?(Array)
-
-          signature = details.filter_map do |detail|
-            detail['signature'] if detail['signature'].is_a?(String)
-          end.first
-          return signature if signature
+        def reasoning_detail_target(detail)
+          index = detail['index']
+          return nil unless index
 
-          encrypted = details.find { |detail| detail['type'] == 'reasoning.encrypted' && detail['data'].is_a?(String) }
-          encrypted&.dig('data')
+          @raw_reasoning.find { |entry| entry['index'] == index && entry['type'] == detail['type'] }
         end
       end
     end

data/lib/ruby_llm/providers/openrouter/videos.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class OpenRouter
+      # OpenRouter's asynchronous video generation API. Reference images
+      # become frame_images entries, and finished videos are downloaded
+      # from the job's authenticated content endpoint.
+      module Videos
+        FRAME_TYPES = %w[first_frame last_frame].freeze
+
+        def video_url
+          'videos'
+        end
+
+        def render_video_payload(prompt, model:, with: [], provider_options: {})
+          payload = { model: model, prompt: prompt }
+          payload[:frame_images] = frame_images(with) if with.any?
+
+          payload.merge(provider_options)
+        end
+
+        def parse_video_job(response, model:)
+          id = response.body['id']
+          raise Error.new('OpenRouter did not return a video job', response:) unless id
+
+          VideoJob.new(id: id, protocol: self, model: model, status: job_status(response.body), raw: response.body)
+        end
+
+        def video_job_url(job)
+          "videos/#{job.id}"
+        end
+
+        def parse_video_job_status(response, job:) # rubocop:disable Lint/UnusedMethodArgument
+          body = response.body
+          status = job_status(body)
+          state = { status: status, raw: body }
+          state[:error] = body['error'] || body['status'] if status == :failed
+          state
+        end
+
+        def download_video(job)
+          response = @connection.get "videos/#{job.id}/content?index=0"
+
+          Video.new(
+            data: response.body,
+            mime_type: response.headers['content-type'] || 'video/mp4',
+            model: job.model,
+            raw: job.raw
+          )
+        end
+
+        private
+
+        def job_status(body)
+          case body['status']
+          when 'completed' then :completed
+          when 'failed' then :failed
+          else :pending
+          end
+        end
+
+        def validate_animate_inputs!(with:)
+          raise Error, 'OpenRouter video generation takes at most first and last frame images' if with.size > 2
+
+          with.each do |attachment|
+            next if attachment.url?
+            raise UnsupportedAttachmentError, attachment.mime_type unless attachment.image?
+          end
+        end
+
+        def frame_images(attachments)
+          attachments.zip(FRAME_TYPES).map do |attachment, frame_type|
+            url = attachment.url? ? attachment.source.to_s : attachment.for_llm
+            { type: 'image_url', image_url: { url: url }, frame_type: frame_type }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/openrouter.rb

@@ -3,58 +3,116 @@
 module RubyLLM
   module Providers
     # OpenRouter API integration.
-    class OpenRouter < OpenAI
-      include OpenRouter::Chat
-      include OpenRouter::Models
-      include OpenRouter::Streaming
-      include OpenRouter::Images
+    class OpenRouter < Provider
+      # OpenRouter's dialect of the Chat Completions API.
+      class ChatCompletions < Protocols::ChatCompletions
+        include OpenRouter::Chat
+        include OpenRouter::Embeddings
+        include OpenRouter::Images
+        include OpenRouter::Models
+        include OpenRouter::Speech
+        include OpenRouter::Streaming
+        include Protocols::ChatCompletions::Rerank
+        include OpenRouter::Videos
+        include Protocols::OpenRouter::Transcription
+
+        # OpenRouter runs its server tools transparently: results surface as
+        # citations and usage counters rather than discrete content blocks.
+        SERVER_TOOL_ALIASES = %i[
+          web_search web_fetch datetime image_generation apply_patch shell
+        ].to_h { |name| [name, { tool: { type: "openrouter:#{name}" } }] }.merge(
+          url_context: { tool: { type: 'openrouter:web_fetch' } },
+          code_execution: { tool: { type: 'openrouter:shell' } }
+        ).freeze
+
+        def server_tool_aliases
+          SERVER_TOOL_ALIASES
+        end
+      end
+
+      protocol :chat_completions, ChatCompletions, batches: Protocols::OpenRouter::Batches
+      protocol :responses, Protocols::OpenRouter::Responses
+      protocol :files, Protocols::OpenRouter::Files
+
+      def resolve_protocol(name, model, **request)
+        return fetch_protocol(:chat_completions) if !name && request[:operation]
+
+        super
+      end
 
       def api_base
         @config.openrouter_api_base || 'https://openrouter.ai/api/v1'
       end
 
+      def batch_api_base
+        "#{api_base.sub(%r{/v1/?\z}, '')}/beta/batches"
+      end
+
       def headers
         {
-          'Authorization' => "Bearer #{@config.openrouter_api_key}"
+          'Authorization' => "Bearer #{@config.openrouter_api_key}",
+          'HTTP-Referer' => @config.openrouter_app_url || 'https://rubyllm.com',
+          'X-OpenRouter-Title' => @config.openrouter_app_name || 'RubyLLM'
         }
       end
 
       def parse_error(response)
-        return if response.body.empty?
+        body = parse_error_body(response)
+        return unless body
 
-        body = try_parse_json(response.body)
         case body
         when Hash
           parse_error_part_message body
         when Array
-          body.map do |part|
+          messages = body.filter_map do |part|
             parse_error_part_message part
-          end.join('. ')
+          end.reject(&:empty?)
+          messages.join('. ') unless messages.empty?
         else
           body
         end
       end
 
+      class << self
+        def configuration_options
+          %i[openrouter_api_key openrouter_api_base openrouter_app_url openrouter_app_name]
+        end
+
+        def configuration_requirements
+          %i[openrouter_api_key]
+        end
+      end
+
       private
 
       def parse_error_part_message(part)
-        message = part.dig('error', 'message')
-        raw = try_parse_json(part.dig('error', 'metadata', 'raw'))
+        return error_message(part) unless part.is_a?(Hash)
+
+        error = part['error']
+        message = error_message(error)
+        metadata = error['metadata'] if error.is_a?(Hash)
+        return message unless metadata.is_a?(Hash)
+
+        raw = try_parse_json(metadata['raw'])
         return message unless raw.is_a?(Hash)
 
-        raw_message = raw.dig('error', 'message')
+        raw_message = error_message(raw['error'])
         return [message, raw_message].compact.join(' - ') if raw_message
 
         message
       end
 
-      class << self
-        def configuration_options
-          %i[openrouter_api_key openrouter_api_base]
-        end
-
-        def configuration_requirements
-          %i[openrouter_api_key]
+      def error_message(value)
+        case value
+        when Hash
+          value['message']
+        when Array
+          messages = value.filter_map { |part| error_message(part) }
+          messages.join('. ') unless messages.empty?
+        when nil
+          nil
+        else
+          value.to_s
         end
       end
     end

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

@@ -11,15 +11,8 @@ module RubyLLM
           role.to_s
         end
 
-        def format_messages(messages)
-          messages.map do |msg|
-            {
-              role: format_role(msg.role),
-              content: Perplexity::Media.format_content(msg.content),
-              tool_calls: OpenAI::Tools.format_tool_calls(msg.tool_calls),
-              tool_call_id: msg.tool_call_id
-            }.compact.merge(OpenAI::Chat.format_thinking(msg))
-          end
+        def format_content(content, attachments = [])
+          Perplexity::Media.format_content(content, attachments)
         end
       end
     end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Perplexity
+      # Embeddings methods of the Perplexity API integration
+      module Embeddings
+        module_function
+
+        def embedding_url(...)
+          'v1/embeddings'
+        end
+
+        # Perplexity serves base64-encoded signed int8 vectors.
+        def parse_embedding_response(response, model:, text:)
+          data = response.body
+          input_tokens = data.dig('usage', 'prompt_tokens')
+          vectors = Array(data['data']).map { |vector| decode_embedding(vector['embedding']) }
+          vectors = vectors.first if vectors.length == 1 && !text.is_a?(Array)
+
+          Embedding.new(vectors:, model:, input_tokens:)
+        end
+
+        def decode_embedding(embedding)
+          return embedding unless embedding.is_a?(String)
+
+          Base64.decode64(embedding).unpack('c*')
+        end
+      end
+    end
+  end
+end

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

@@ -9,31 +9,19 @@ module RubyLLM
 
         SUPPORTED_DOCUMENT_EXTENSIONS = %w[pdf doc docx txt rtf].freeze
 
-        def format_content(content) # rubocop:disable Metrics/PerceivedComplexity
-          if content.is_a?(RubyLLM::Content::Raw)
-            value = content.value
-            return value.is_a?(Hash) ? value.to_json : value
-          end
-          return content.to_json if content.is_a?(Hash) || content.is_a?(Array)
-          return content unless content.is_a?(Content)
-
-          parts = []
-          parts << OpenAI::Media.format_text(content.text) if content.text
-
-          content.attachments.each do |attachment|
+        def format_content(content, attachments = [])
+          Protocols::ChatCompletions::Media.format_parts(content, attachments) do |attachment|
             case attachment.type
             when :image
-              parts << OpenAI::Media.format_image(attachment)
+              Protocols::ChatCompletions::Media.format_image(attachment)
             when :pdf, :document
-              parts << format_document(attachment)
+              format_document(attachment)
             when :text
-              parts << format_text_attachment(attachment)
+              Protocols::ChatCompletions::Media.format_text_file(attachment)
             else
               raise UnsupportedAttachmentError, attachment.mime_type
             end
           end
-
-          parts
         end
 
         def format_document(attachment)
@@ -47,10 +35,6 @@ module RubyLLM
           }
         end
 
-        def format_text_attachment(attachment)
-          OpenAI::Media.format_text_file(attachment)
-        end
-
         def supported_file?(attachment)
           return true if attachment.pdf?
 

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

@@ -5,35 +5,102 @@ module RubyLLM
     class Perplexity
       # Models methods of the Perplexity API integration
       module Models
-        MODEL_IDS = %w[
+        SEARCH_MODEL_IDS = %w[
           sonar
           sonar-pro
-          sonar-reasoning
           sonar-reasoning-pro
           sonar-deep-research
         ].freeze
+        EMBEDDING_MODEL_IDS = %w[
+          pplx-embed-v1-0.6b
+          pplx-embed-v1-4b
+        ].freeze
+        STATIC_MODEL_IDS = (SEARCH_MODEL_IDS + EMBEDDING_MODEL_IDS).freeze
+        STATIC_MODEL_DATA = {
+          'sonar' => {
+            context_window: 128_000, input_price: 1.0, output_price: 1.0,
+            capabilities: %w[streaming structured_output citations]
+          },
+          'sonar-pro' => {
+            context_window: 200_000, input_price: 3.0, output_price: 15.0,
+            capabilities: %w[streaming structured_output citations]
+          },
+          'sonar-reasoning-pro' => {
+            context_window: 128_000, input_price: 2.0, output_price: 8.0,
+            capabilities: %w[streaming structured_output citations reasoning]
+          },
+          'sonar-deep-research' => {
+            context_window: 128_000, input_price: 2.0, output_price: 8.0, reasoning_price: 3.0,
+            capabilities: %w[streaming structured_output citations reasoning]
+          },
+          'pplx-embed-v1-0.6b' => { context_window: 32_768, input_price: 0.004 },
+          'pplx-embed-v1-4b' => { context_window: 32_768, input_price: 0.03 }
+        }.freeze
+
+        def models_url
+          'v1/models'
+        end
+
+        def list_models
+          super
+        rescue Error => e
+          RubyLLM.logger.warn "Perplexity models endpoint failed (#{e.message}). Using the static model list."
+          static_models(@provider.slug)
+        end
+
+        # The models endpoint lists the multi-model catalog but not the search
+        # or embedding models, so those ride along statically.
+        def parse_list_models_response(response, slug)
+          listed = Array(response.body['data']).map do |model_data|
+            create_model_info(model_data['id'], slug, pricing: endpoint_pricing(model_data['pricing']))
+          end
 
-        def list_models(**)
-          slug = 'perplexity'
-          parse_list_models_response(nil, slug, Perplexity::Capabilities)
+          static_models(slug, ids: STATIC_MODEL_IDS - listed.map(&:id)) + listed
         end
 
-        def parse_list_models_response(_response, slug, capabilities)
-          MODEL_IDS.map { |id| create_model_info(id, slug, capabilities) }
+        def static_models(slug, ids: STATIC_MODEL_IDS)
+          ids.map { |id| create_model_info(id, slug) }
         end
 
-        def create_model_info(id, slug, capabilities)
-          Model::Info.new(
+        def create_model_info(id, slug, pricing: nil)
+          static = STATIC_MODEL_DATA.fetch(id, {})
+
+          Model.new(
             id: id,
             name: id,
             provider: slug,
-            context_window: capabilities.context_window_for(id),
-            max_output_tokens: capabilities.max_tokens_for(id),
-            capabilities: capabilities.critical_capabilities_for(id),
-            pricing: capabilities.pricing_for(id),
+            context_window: static[:context_window],
+            capabilities: static.fetch(:capabilities, []),
+            pricing: pricing || static_pricing(static),
+            modalities: modalities_for(id),
             metadata: {}
           )
         end
+
+        def modalities_for(id)
+          { input: %w[text], output: %w[embeddings] } if EMBEDDING_MODEL_IDS.include?(id)
+        end
+
+        def endpoint_pricing(pricing)
+          return nil unless pricing.is_a?(Hash)
+
+          standard = {
+            input_per_million: pricing['input'],
+            output_per_million: pricing['output'],
+            cache_read_input_per_million: pricing['cache_read'],
+            cache_write_input_per_million: pricing['cache_write']
+          }.compact
+          { text_tokens: { standard: standard } } unless standard.empty?
+        end
+
+        def static_pricing(data)
+          return {} unless data[:input_price]
+
+          standard = { input_per_million: data[:input_price] }
+          standard[:output_per_million] = data[:output_price] if data[:output_price]
+          standard[:reasoning_output_per_million] = data[:reasoning_price] if data[:reasoning_price]
+          { text_tokens: { standard: standard } }
+        end
       end
     end
   end

data/lib/ruby_llm/providers/perplexity.rb

@@ -3,14 +3,26 @@
 module RubyLLM
   module Providers
     # Perplexity API integration.
-    class Perplexity < OpenAI
-      include Perplexity::Chat
-      include Perplexity::Models
+    class Perplexity < Provider
+      # Perplexity's dialect of the Chat Completions API.
+      class ChatCompletions < Protocols::ChatCompletions
+        include Perplexity::Chat
+        include Perplexity::Embeddings
+        include Perplexity::Models
+      end
+
+      protocol :chat_completions, ChatCompletions
+      protocol :router_chat_completions, Protocols::Perplexity::Router
+      protocol :files, Protocols::Perplexity::Files
 
       def api_base
         @config.perplexity_api_base || 'https://api.perplexity.ai'
       end
 
+      def router_url(operation) # :nodoc:
+        "#{api_base.delete_suffix('/').delete_suffix('/router/v1')}/router/v1/#{operation}"
+      end
+
       def headers
         {
           'Authorization' => "Bearer #{@config.perplexity_api_key}",
@@ -18,26 +30,12 @@ module RubyLLM
         }
       end
 
-      class << self
-        def capabilities
-          Perplexity::Capabilities
-        end
-
-        def configuration_options
-          %i[perplexity_api_key perplexity_api_base]
-        end
-
-        def configuration_requirements
-          %i[perplexity_api_key]
-        end
-      end
-
       def parse_error(response)
-        body = response.body
-        return if body.empty?
+        body = parse_error_body(response)
+        return unless body
 
         # If response is HTML (Perplexity returns HTML for auth errors)
-        if body.include?('<html>') && body.include?('<title>')
+        if body.is_a?(String) && body.include?('<html>') && body.include?('<title>')
           title_match = body.match(%r{<title>(.+?)</title>})
           if title_match
             message = title_match[1]
@@ -47,6 +45,16 @@ module RubyLLM
         end
         super
       end
+
+      class << self
+        def configuration_options
+          %i[perplexity_api_key perplexity_api_base]
+        end
+
+        def configuration_requirements
+          %i[perplexity_api_key]
+        end
+      end
     end
   end
 end

data/lib/ruby_llm/providers/vertexai/anthropic/batches.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class VertexAI < Provider
+      class Anthropic
+        # Vertex AI Claude batch prediction rows.
+        module Batches
+          include Protocols::VertexAI::BatchPrediction
+
+          private
+
+          def vertex_batch_request(request)
+            {
+              custom_id: request[:custom_id],
+              request: batch_payload(request)
+            }
+          end
+
+          def validate_batch_requests!(requests)
+            if @config.vertexai_location.to_s == 'global'
+              raise ConfigurationError, 'vertexai Anthropic batches require a regional vertexai_location'
+            end
+
+            return if requests.all? { |request| anthropic_batch_payload?(request.fetch(:payload)) }
+
+            raise Error, 'vertexai Anthropic batch requests require Anthropic message payloads'
+          end
+
+          def anthropic_batch_payload?(payload)
+            payload.key?(:messages) || payload.key?('messages')
+          end
+
+          def vertex_batch_model_path(model)
+            @provider.model_path(model, publisher: 'anthropic')
+          end
+
+          def parse_vertex_batch_result(line, fallback_index)
+            index = vertex_batch_result_index(line, fallback_index)
+            body = line.dig('response', 'body') || line['response']
+
+            if body
+              [index, parse_completion_body(body, raw: body)]
+            else
+              [index, nil, batch_failure(index, line.dig('status', 'message') || batch_error_message(line))]
+            end
+          end
+        end
+      end
+    end
+  end
+end