raif 1.0.0 → 1.2.0

data/app/models/raif/llms/open_ai_responses.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+class Raif::Llms::OpenAiResponses < Raif::Llms::OpenAiBase
+  include Raif::Concerns::Llms::OpenAiResponses::MessageFormatting
+  include Raif::Concerns::Llms::OpenAiResponses::ToolFormatting
+
+private
+
+  def api_path
+    "responses"
+  end
+
+  def streaming_response_type
+    Raif::StreamingResponses::OpenAiResponses
+  end
+
+  def update_model_completion(model_completion, response_json)
+    model_completion.update!(
+      response_id: response_json["id"],
+      response_tool_calls: extract_response_tool_calls(response_json),
+      raw_response: extract_raw_response(response_json),
+      response_array: response_json["output"],
+      citations: extract_citations(response_json),
+      completion_tokens: response_json.dig("usage", "output_tokens"),
+      prompt_tokens: response_json.dig("usage", "input_tokens"),
+      total_tokens: response_json.dig("usage", "total_tokens")
+    )
+  end
+
+  def extract_response_tool_calls(resp)
+    return if resp["output"].blank?
+
+    tool_calls = []
+    resp["output"].each do |output_item|
+      next unless output_item["type"] == "function_call"
+
+      tool_calls << {
+        "name" => output_item["name"],
+        "arguments" => JSON.parse(output_item["arguments"])
+      }
+    end
+
+    tool_calls.any? ? tool_calls : nil
+  end
+
+  def extract_raw_response(resp)
+    text_outputs = []
+
+    output_messages = resp["output"]&.select{ |output_item| output_item["type"] == "message" }
+    output_messages&.each do |output_message|
+      output_message["content"].each do |content_item|
+        text_outputs << content_item["text"] if content_item["type"] == "output_text"
+      end
+    end
+
+    text_outputs.join("\n").presence
+  end
+
+  def extract_citations(resp)
+    return [] if resp["output"].blank?
+
+    citations = []
+
+    # Look through output messages for citations in annotations
+    output_messages = resp["output"].select{|output_item| output_item["type"] == "message" }
+    output_messages.each do |output_message|
+      next unless output_message["content"].present?
+
+      output_message["content"].each do |content_item|
+        next unless content_item["type"] == "output_text" && content_item["annotations"].present?
+
+        content_item["annotations"].each do |annotation|
+          next unless annotation["type"] == "url_citation"
+
+          citations << {
+            "url" => Raif::Utils::HtmlFragmentProcessor.strip_tracking_parameters(annotation["url"]),
+            "title" => annotation["title"]
+          }
+        end
+      end
+    end
+
+    citations.uniq{|citation| citation["url"] }
+  end
+
+  def build_request_parameters(model_completion)
+    parameters = {
+      model: api_name,
+      input: model_completion.messages,
+    }
+
+    if supports_temperature?
+      parameters[:temperature] = model_completion.temperature.to_f
+    end
+
+    parameters[:stream] = true if model_completion.stream_response?
+
+    # Add instructions (system prompt) if present
+    formatted_system_prompt = format_system_prompt(model_completion)
+    if formatted_system_prompt.present?
+      parameters[:instructions] = formatted_system_prompt
+    end
+
+    # Add max_output_tokens if specified
+    if model_completion.max_completion_tokens.present?
+      parameters[:max_output_tokens] = model_completion.max_completion_tokens
+    end
+
+    # If the LLM supports native tool use and there are available tools, add them to the parameters
+    if supports_native_tool_use?
+      tools = build_tools_parameter(model_completion)
+      parameters[:tools] = tools unless tools.blank?
+    end
+
+    # Add response format if needed. Default will be { "type": "text" }
+    response_format = determine_response_format(model_completion)
+    if response_format.present?
+      parameters[:text] = { format: response_format }
+      model_completion.response_format_parameter = response_format[:type]
+    end
+
+    parameters
+  end
+
+  def determine_response_format(model_completion)
+    # Only configure response format for JSON outputs
+    return unless model_completion.response_format_json?
+
+    if model_completion.json_response_schema.present? && supports_structured_outputs?
+      validate_json_schema!(model_completion.json_response_schema)
+
+      {
+        type: "json_schema",
+        name: "json_response_schema",
+        strict: true,
+        schema: model_completion.json_response_schema
+      }
+    else
+      # Default JSON mode for OpenAI models that don't support structured outputs or no schema is provided
+      { type: "json_object" }
+    end
+  end
+
+end

data/app/models/raif/llms/open_router.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class Raif::Llms::OpenRouter < Raif::Llm
+  include Raif::Concerns::Llms::OpenAiCompletions::MessageFormatting
+  include Raif::Concerns::Llms::OpenAiCompletions::ToolFormatting
+  include Raif::Concerns::Llms::OpenAi::JsonSchemaValidation
+
+  def perform_model_completion!(model_completion, &block)
+    model_completion.temperature ||= default_temperature
+    parameters = build_request_parameters(model_completion)
+    response = connection.post("chat/completions") do |req|
+      req.body = parameters
+      req.options.on_data = streaming_chunk_handler(model_completion, &block) if model_completion.stream_response?
+    end
+
+    unless model_completion.stream_response?
+      update_model_completion(model_completion, response.body)
+    end
+
+    model_completion
+  end
+
+private
+
+  def connection
+    @connection ||= Faraday.new(url: "https://openrouter.ai/api/v1") do |f|
+      f.headers["Authorization"] = "Bearer #{Raif.config.open_router_api_key}"
+      f.headers["HTTP-Referer"] = Raif.config.open_router_site_url if Raif.config.open_router_site_url.present?
+      f.headers["X-Title"] = Raif.config.open_router_app_name if Raif.config.open_router_app_name.present?
+      f.request :json
+      f.response :json
+      f.response :raise_error
+    end
+  end
+
+  def streaming_response_type
+    Raif::StreamingResponses::OpenAiCompletions
+  end
+
+  def update_model_completion(model_completion, response_json)
+    model_completion.update!(
+      response_tool_calls: extract_response_tool_calls(response_json),
+      raw_response: response_json.dig("choices", 0, "message", "content"),
+      response_array: response_json["choices"],
+      completion_tokens: response_json.dig("usage", "completion_tokens"),
+      prompt_tokens: response_json.dig("usage", "prompt_tokens"),
+      total_tokens: response_json.dig("usage", "total_tokens")
+    )
+  end
+
+  def build_request_parameters(model_completion)
+    params = {
+      model: model_completion.model_api_name,
+      messages: model_completion.messages,
+      temperature: model_completion.temperature.to_f,
+      max_tokens: model_completion.max_completion_tokens || default_max_completion_tokens,
+    }
+
+    # Add system message to the messages array if present
+    if model_completion.system_prompt.present?
+      params[:messages].unshift({ "role" => "system", "content" => model_completion.system_prompt })
+    end
+
+    if supports_native_tool_use?
+      tools = build_tools_parameter(model_completion)
+      params[:tools] = tools unless tools.blank?
+    end
+
+    if model_completion.stream_response?
+      # Ask for usage stats in the last chunk
+      params[:stream] = true
+      params[:stream_options] = { include_usage: true }
+    end
+
+    params
+  end
+
+  def extract_response_tool_calls(resp)
+    return if resp.dig("choices", 0, "message", "tool_calls").blank?
+
+    resp.dig("choices", 0, "message", "tool_calls").map do |tool_call|
+      {
+        "name" => tool_call["function"]["name"],
+        "arguments" => JSON.parse(tool_call["function"]["arguments"])
+      }
+    end
+  end
+end

data/app/models/raif/model_completion.rb

@@ -12,17 +12,38 @@ class Raif::ModelCompletion < Raif::ApplicationRecord
   delegate :json_response_schema, to: :source, allow_nil: true
 
   before_save :set_total_tokens
+  before_save :calculate_costs
 
   after_initialize -> { self.messages ||= [] }
   after_initialize -> { self.available_model_tools ||= [] }
+  after_initialize -> { self.response_array ||= [] }
+  after_initialize -> { self.citations ||= [] }
 
   def json_response_schema
     source.json_response_schema if source&.respond_to?(:json_response_schema)
   end
 
-protected
-
   def set_total_tokens
     self.total_tokens ||= completion_tokens.present? && prompt_tokens.present? ? completion_tokens + prompt_tokens : nil
   end
+
+  def calculate_costs
+    if prompt_tokens.present? && llm_config[:input_token_cost].present?
+      self.prompt_token_cost = llm_config[:input_token_cost] * prompt_tokens
+    end
+
+    if completion_tokens.present? && llm_config[:output_token_cost].present?
+      self.output_token_cost = llm_config[:output_token_cost] * completion_tokens
+    end
+
+    if prompt_token_cost.present? || output_token_cost.present?
+      self.total_cost = (prompt_token_cost || 0) + (output_token_cost || 0)
+    end
+  end
+
+private
+
+  def llm_config
+    @llm_config ||= Raif.llm_config(llm_model_key.to_sym)
+  end
 end

data/app/models/raif/model_file_input.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class Raif::ModelFileInput
+  include ActiveModel::Model
+
+  attr_accessor :input, :url, :base64_data, :filename, :content_type, :source_type
+
+  validates :url, format: { with: URI::DEFAULT_PARSER.make_regexp(%w[http https]), message: "is not a valid URL" }, allow_nil: true
+  validates :base64_data, presence: { message: "could not be read from input" }, if: -> { input.present? }
+  validates :content_type, presence: { message: "could not be determined" }, if: -> { input.present? }
+
+  def initialize(input: nil, url: nil)
+    raise ArgumentError, "You must provide either an input or a URL" if input.blank? && url.blank?
+    raise ArgumentError, "Provide either input or URL, not both" if input.present? && url.present?
+
+    super(input: input, url: url)
+
+    if url.present?
+      @source_type = :url
+    elsif input.present?
+      @source_type = :file_content
+      process_input!
+    end
+
+    unless valid?
+      raise Raif::Errors::InvalidModelFileInputError, errors.full_messages.join(", ")
+    end
+  end
+
+  def inspect
+    "#<#{self.class.name} input=#{input.inspect} url=#{url.inspect} base64_data=#{base64_data&.truncate(20)} filename=#{filename.inspect} content_type=#{content_type.inspect} source_type=#{source_type.inspect}>" # rubocop:disable Layout/LineLength
+  end
+
+  def file_bytes
+    Base64.strict_decode64(base64_data)
+  end
+
+private
+
+  def process_input!
+    if input_is_active_storage_blob?
+      process_active_storage_blob(input)
+      return
+    elsif input_has_active_storage_blob?
+      process_active_storage_blob(input.blob)
+      return
+    end
+
+    case input
+    when String
+      process_string_input
+    when Pathname
+      process_from_path
+    when File, Tempfile, IO, StringIO
+      read_from_io
+    else
+      raise Raif::Errors::InvalidModelFileInputError, "Invalid input type for #{self.class.name} (got #{input.class})"
+    end
+  end
+
+  def process_string_input
+    if File.exist?(input)
+      @input = Pathname.new(input)
+      process_from_path
+    else
+      raise Raif::Errors::InvalidModelFileInputError, "File does not exist: #{input}"
+    end
+  end
+
+  def process_active_storage_blob(blob)
+    @filename = blob.filename.to_s
+    @content_type = blob.content_type
+    @base64_data = Base64.strict_encode64(blob.download)
+  end
+
+  def process_from_path
+    @filename = input.basename.to_s
+    @content_type = Marcel::MimeType.for(input)
+    @base64_data = Base64.strict_encode64(input.binread)
+  end
+
+  def read_from_io
+    @filename = input.respond_to?(:path) ? File.basename(input.path) : nil
+    @content_type = Marcel::MimeType.for(input)
+    try_rewind
+    @base64_data = Base64.strict_encode64(input.read)
+  end
+
+  def try_rewind
+    input.rewind if input.respond_to?(:rewind)
+  rescue IOError => e
+    logger.error "Failed to rewind IO: #{e.message}"
+    logger.error e.backtrace.join("\n")
+  end
+
+  def input_looks_like_base64?
+    input.match?(%r{\A[a-zA-Z0-9+/\n\r]+={0,2}\z})
+  end
+
+  def input_has_active_storage_blob?
+    return false unless defined?(ActiveStorage)
+    return false unless input.respond_to?(:blob)
+
+    input.blob.is_a?(ActiveStorage::Blob)
+  end
+
+  def input_is_active_storage_blob?
+    return false unless defined?(ActiveStorage)
+
+    input.is_a?(ActiveStorage::Blob)
+  end
+
+end

data/app/models/raif/model_image_input.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Raif::ModelImageInput < Raif::ModelFileInput
+end

data/app/models/raif/model_tool.rb

@@ -1,69 +1,99 @@
 # frozen_string_literal: true
 
 class Raif::ModelTool
+  include Raif::Concerns::JsonSchemaDefinition
 
-  delegate :tool_name, :tool_description, :tool_arguments_schema, to: :class
-
-  # The description of the tool that will be provided to the model
-  # when giving it a list of available tools.
-  def self.description_for_llm
-    <<~DESCRIPTION
-      Name: #{tool_name}
-      Description: #{tool_description}
-      Arguments Schema:
-      #{JSON.pretty_generate(tool_arguments_schema)}
-      Example Usage:
-      #{JSON.pretty_generate(example_model_invocation)}
-    DESCRIPTION
-  end
+  delegate :tool_name, :tool_description, :tool_arguments_schema, :example_model_invocation, to: :class
 
-  # The name of the tool as it will be provided to the model & used in the model invocation.
-  # Default for something like Raif::ModelTools::WikipediaSearch would be "wikipedia_search"
-  def self.tool_name
-    name.split("::").last.underscore
-  end
+  class << self
+    # The description of the tool that will be provided to the model
+    # when giving it a list of available tools.
+    def description_for_llm
+      <<~DESCRIPTION
+        Name: #{tool_name}
+        Description: #{tool_description}
+        Arguments Schema:
+        #{JSON.pretty_generate(tool_arguments_schema)}
+        Example Usage:
+        #{JSON.pretty_generate(example_model_invocation)}
+      DESCRIPTION
+    end
 
-  def self.tool_description
-    raise NotImplementedError, "#{self.class.name}#tool_description is not implemented"
-  end
+    # The name of the tool as it will be provided to the model & used in the model invocation.
+    # Default for something like Raif::ModelTools::WikipediaSearch would be "wikipedia_search"
+    def tool_name
+      name.split("::").last.underscore
+    end
 
-  def self.example_model_invocation
-    raise NotImplementedError, "#{self.class.name}#example_model_invocation is not implemented"
-  end
+    def tool_description(&block)
+      if block_given?
+        @tool_description = block.call
+      elsif @tool_description.present?
+        @tool_description
+      else
+        raise NotImplementedError, "#{name}#tool_description is not implemented"
+      end
+    end
 
-  def self.process_invocation(invocation)
-    raise NotImplementedError, "#{self.class.name}#process_invocation is not implemented"
-  end
+    def example_model_invocation(&block)
+      if block_given?
+        @example_model_invocation = block.call
+      elsif @example_model_invocation.present?
+        @example_model_invocation
+      else
+        raise NotImplementedError, "#{name}#example_model_invocation is not implemented"
+      end
+    end
 
-  def self.invocation_partial_name
-    name.gsub("Raif::ModelTools::", "").underscore
-  end
+    def process_invocation(invocation)
+      raise NotImplementedError, "#{name}#process_invocation is not implemented"
+    end
 
-  def self.tool_arguments_schema
-    raise NotImplementedError, "#{self.class.name}#tool_arguments_schema is not implemented"
-  end
+    def invocation_partial_name
+      name.gsub("Raif::ModelTools::", "").underscore
+    end
 
-  def self.renderable?
-    true
-  end
+    def tool_arguments_schema(&block)
+      if block_given?
+        json_schema_definition(:tool_arguments, &block)
+      elsif schema_defined?(:tool_arguments)
+        schema_for(:tool_arguments)
+      else
+        raise NotImplementedError,
+          "#{name} must define tool arguments schema via tool_arguments_schema or override #{name}.tool_arguments_schema"
+      end
+    end
+
+    def provider_managed?
+      false
+    end
 
-  def self.invoke_tool(tool_arguments:, source:)
-    tool_invocation = Raif::ModelToolInvocation.new(
-      source: source,
-      tool_type: name,
-      tool_arguments: tool_arguments
-    )
-
-    ActiveRecord::Base.transaction do
-      tool_invocation.save!
-      process_invocation(tool_invocation)
-      tool_invocation.completed!
+    def renderable?
+      true
     end
 
-    tool_invocation
-  rescue StandardError => e
-    tool_invocation.failed!
-    raise e
+    def triggers_observation_to_model?
+      false
+    end
+
+    def invoke_tool(tool_arguments:, source:)
+      tool_invocation = Raif::ModelToolInvocation.new(
+        source: source,
+        tool_type: name,
+        tool_arguments: tool_arguments
+      )
+
+      ActiveRecord::Base.transaction do
+        tool_invocation.save!
+        process_invocation(tool_invocation)
+        tool_invocation.completed!
+      end
+
+      tool_invocation
+    rescue StandardError => e
+      tool_invocation.failed!
+      raise e
+    end
   end
 
 end

data/app/models/raif/model_tool_invocation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "json-schema"
-
 class Raif::ModelToolInvocation < Raif::ApplicationRecord
   belongs_to :source, polymorphic: true
 
@@ -11,7 +9,11 @@ class Raif::ModelToolInvocation < Raif::ApplicationRecord
   validates :tool_type, presence: true
   validate :ensure_valid_tool_argument_schema, if: -> { tool_type.present? && tool_arguments_schema.present? }
 
-  delegate :tool_arguments_schema, :renderable?, :tool_name, to: :tool
+  delegate :tool_arguments_schema,
+    :renderable?,
+    :tool_name,
+    :triggers_observation_to_model?,
+    to: :tool
 
   boolean_timestamp :completed_at
   boolean_timestamp :failed_at
@@ -25,9 +27,9 @@ class Raif::ModelToolInvocation < Raif::ApplicationRecord
   end
 
   def result_llm_message
-    if result.present?
-      "Result from #{tool_name}: #{result.to_json}"
-    end
+    return unless tool.respond_to?(:observation_for_invocation)
+
+    tool.observation_for_invocation(self)
   end
 
   def to_partial_path

data/app/models/raif/model_tools/agent_final_answer.rb

@@ -1,46 +1,37 @@
 # frozen_string_literal: true
 
 class Raif::ModelTools::AgentFinalAnswer < Raif::ModelTool
+  tool_arguments_schema do
+    string "final_answer", description: "Your complete and final answer to the user's question or task"
+  end
 
-  def self.example_model_invocation
+  example_model_invocation do
     {
       "name" => tool_name,
       "arguments" => { "final_answer": "The answer to the user's question or task" }
     }
   end
 
-  def self.tool_arguments_schema
-    {
-      type: "object",
-      additionalProperties: false,
-      required: ["final_answer"],
-      properties: {
-        final_answer: {
-          type: "string",
-          description: "Your complete and final answer to the user's question or task"
-        }
-      }
-    }
-  end
-
-  def self.tool_description
+  tool_description do
     "Provide your final answer to the user's question or task"
   end
 
-  def self.observation_for_invocation(tool_invocation)
-    return "No answer provided" unless tool_invocation.result.present?
+  class << self
+    def observation_for_invocation(tool_invocation)
+      return "No answer provided" unless tool_invocation.result.present?
 
-    tool_invocation.result["final_answer"]
-  end
+      tool_invocation.result["final_answer"]
+    end
 
-  def self.process_invocation(tool_invocation)
-    tool_invocation.update!(
-      result: {
-        final_answer: tool_invocation.tool_arguments["final_answer"]
-      }
-    )
+    def process_invocation(tool_invocation)
+      tool_invocation.update!(
+        result: {
+          final_answer: tool_invocation.tool_arguments["final_answer"]
+        }
+      )
 
-    tool_invocation.result
+      tool_invocation.result
+    end
   end
 
 end