raif 1.3.0 → 1.5.0

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

@@ -40,4 +40,21 @@ module Raif::Concerns::Llms::OpenAiResponses::MessageFormatting
       raise Raif::Errors::InvalidModelFileInputError, "Invalid model image input source type: #{file_input.source_type}"
     end
   end
+
+  def format_tool_call_message(tool_call)
+    {
+      "type" => "function_call",
+      "call_id" => tool_call["provider_tool_call_id"],
+      "name" => tool_call["name"],
+      "arguments" => JSON.generate(tool_call["arguments"])
+    }
+  end
+
+  def format_tool_call_result_message(tool_call_result)
+    {
+      "type" => "function_call_output",
+      "call_id" => tool_call_result["provider_tool_call_id"],
+      "output" => tool_call_result["result"].is_a?(String) ? tool_call_result["result"] : JSON.generate(tool_call_result["result"])
+    }
+  end
 end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::OpenAiResponses::ResponseToolCalls
+  extend ActiveSupport::Concern
+
+  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 << {
+        "provider_tool_call_id" => output_item["call_id"],
+        "name" => output_item["name"],
+        "arguments" => begin
+          JSON.parse(output_item["arguments"])
+        rescue JSON::ParserError
+          output_item["arguments"]
+        end
+      }
+    end
+
+    tool_calls.any? ? tool_calls : nil
+  end
+end

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

@@ -39,4 +39,12 @@ module Raif::Concerns::Llms::OpenAiResponses::ToolFormatting
         "Invalid provider-managed tool: #{tool.name} for #{key}"
     end
   end
+
+  def build_forced_tool_choice(tool_name)
+    { "type" => "function", "name" => tool_name }
+  end
+
+  def build_required_tool_choice
+    "required"
+  end
 end

data/app/models/raif/concerns/provider_managed_tool_calls.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::ProviderManagedToolCalls
+  extend ActiveSupport::Concern
+
+  # Provider-managed tool data is not normalized by the provider SDKs the same
+  # way developer-managed tool calls are. This method smooths those differences
+  # into one admin-friendly structure for the model completion page.
+  def provider_managed_tool_calls
+    # Memoized for repeated reads during a request/render. This assumes the
+    # completion's response payload is not mutated after first access.
+    @provider_managed_tool_calls ||= begin
+      tool_calls = extract_provider_managed_tool_calls
+      tool_calls = inferred_provider_managed_tool_calls if tool_calls.empty?
+
+      tool_calls.map do |tool_call|
+        next tool_call unless tool_call["tool_name"] == "web_search"
+
+        # Search sources can come from explicit provider result blocks
+        # (Anthropic) or from top-level citations (OpenAI / Google), so we
+        # merge both.
+        tool_call.merge("sources" => merge_provider_managed_sources(tool_call["sources"], citations))
+      end
+    end
+  end
+
+  # Returns citations with URLs sanitized to only allow http/https schemes.
+  def sanitized_citations
+    @sanitized_citations ||= Array(citations).map do |citation|
+      url = citation["url"]
+      safe_url = url.present? && url.match?(%r{\Ahttps?://}i) ? url : nil
+      citation.merge("url" => safe_url)
+    end
+  end
+
+private
+
+  def extract_provider_managed_tool_calls
+    response_blocks = Array(response_array).select { |block| block.is_a?(Hash) }
+    result_blocks_by_tool_use_id = response_blocks.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |block, hash|
+      next if block["tool_use_id"].blank?
+
+      hash[block["tool_use_id"]] << block
+    end
+
+    response_blocks.filter_map do |block|
+      case block["type"]
+      when "server_tool_use"
+        # Anthropic stores the tool invocation in one block and the result in a
+        # separate block keyed by `tool_use_id`.
+        build_provider_managed_server_tool_call(block, result_blocks_by_tool_use_id)
+      when "web_search_call", "web_search_preview",
+           "code_interpreter_call", "code_interpreter",
+           "image_generation_call", "image_generation"
+        # OpenAI Responses persists provider-managed calls as top-level typed
+        # blocks like `web_search_call`, `code_interpreter`, etc.
+        build_provider_managed_tool_call_from_type(block)
+      end
+    end
+  end
+
+  def build_provider_managed_server_tool_call(block, result_blocks_by_tool_use_id)
+    tool_name = normalize_provider_managed_tool_name(block["name"])
+    return unless provider_managed_tool_available?(tool_name)
+
+    raw_result = result_blocks_by_tool_use_id[block["id"]].presence
+    {
+      "tool_name" => tool_name,
+      "provider_tool_call_id" => block["id"],
+      "status" => block["status"],
+      "arguments" => block["input"].presence,
+      "sources" => extract_provider_managed_sources(raw_result),
+      "raw_result" => raw_result,
+      "inferred" => false
+    }
+  end
+
+  def build_provider_managed_tool_call_from_type(block)
+    tool_name = normalize_provider_managed_tool_name(block["type"])
+    return unless provider_managed_tool_available?(tool_name)
+
+    payload = block.except("id", "type", "status").presence
+    {
+      "tool_name" => tool_name,
+      "provider_tool_call_id" => block["id"],
+      "status" => block["status"],
+      "arguments" => payload,
+      "sources" => [],
+      "raw_result" => payload,
+      "inferred" => false
+    }
+  end
+
+  def inferred_provider_managed_tool_calls
+    # Google currently gives us citations for provider-managed web search, but
+    # not a first-class tool call block in `response_array`, so we infer a
+    # single search invocation when web search was available and citations exist.
+    return [] unless provider_managed_tool_available?("web_search") && citations.present?
+
+    [{
+      "tool_name" => "web_search",
+      "provider_tool_call_id" => nil,
+      "status" => "completed",
+      "arguments" => nil,
+      "sources" => merge_provider_managed_sources([], citations),
+      "raw_result" => nil,
+      "inferred" => true
+    }]
+  end
+
+  def extract_provider_managed_sources(result_blocks)
+    Array(result_blocks).flat_map do |result_block|
+      Array(result_block["content"]).filter_map do |content_block|
+        next unless content_block.is_a?(Hash) && content_block["type"] == "web_search_result"
+
+        {
+          "title" => content_block["title"],
+          "url" => normalize_provider_managed_source_url(content_block["url"]),
+          "page_age" => content_block["page_age"]
+        }.compact
+      end
+    end.uniq { |source| source["url"].presence || source["title"] }
+  end
+
+  def merge_provider_managed_sources(existing_sources, extra_sources)
+    (Array(existing_sources) + Array(extra_sources)).filter_map do |source|
+      next unless source.is_a?(Hash)
+
+      {
+        "title" => source["title"],
+        "url" => normalize_provider_managed_source_url(source["url"]),
+        "page_age" => source["page_age"]
+      }.compact.presence
+    end.uniq { |source| source["url"].presence || source["title"] }
+  end
+
+  def normalize_provider_managed_tool_name(name)
+    case name.to_s
+    when "web_search", "web_search_call", "web_search_preview"
+      "web_search"
+    when "code_execution", "code_interpreter", "code_interpreter_call"
+      "code_execution"
+    when "image_generation", "image_generation_call"
+      "image_generation"
+    end
+  end
+
+  def provider_managed_tool_available?(tool_name)
+    return false if tool_name.blank?
+
+    available_model_tools_map[tool_name]&.provider_managed?
+  end
+
+  def normalize_provider_managed_source_url(url)
+    return if url.blank?
+
+    url = Raif::Utils::HtmlFragmentProcessor.strip_tracking_parameters(url)
+    return unless url.match?(%r{\Ahttps?://}i)
+
+    url
+  end
+end

data/app/models/raif/concerns/run_with.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::RunWith
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :_run_with_args, instance_writer: false, default: []
+
+    # Backward compatibility alias
+    class_attribute :_task_run_args, instance_writer: false, default: []
+
+    # Automatically serialize run_with args before validation on create
+    before_validation :serialize_run_with_to_column, on: :create
+  end
+
+  class_methods do
+    # Scope for querying records by run_with arguments
+    # @param args [Hash] Key-value pairs to match in the run_with column
+    # @example
+    #   Task.having_run_with(document: doc)
+    #   Task.having_run_with(user: user, options: { foo: "bar" })
+    def having_run_with(**args)
+      return all if args.empty?
+
+      # Serialize args the same way we do for storage (handles GID conversion)
+      serialized = serialize_run_with(args)
+
+      # Avoid matching all records if args didn't match declared run_with arguments
+      return none if args.any? && serialized.empty?
+
+      # Use database-specific JSON containment query
+      case connection.adapter_name.downcase
+      when "postgresql"
+        # PostgreSQL: Use JSONB containment operator
+        where("run_with @> ?", serialized.to_json)
+      when "mysql2", "trilogy"
+        # MySQL: Use JSON_CONTAINS function
+        where("JSON_CONTAINS(run_with, ?)", serialized.to_json)
+      else
+        raise "Unsupported database: #{connection.adapter_name}"
+      end
+    end
+
+    # DSL for declaring persistent run arguments that will be serialized to the database
+    # @param name [Symbol] The name of the argument
+    def run_with(name)
+      # Ensure each class has its own array copy
+      self._run_with_args = _run_with_args.dup
+      _run_with_args << name.to_sym
+
+      # Keep backward compatibility for _task_run_args class attribute
+      self._task_run_args = _task_run_args.dup
+      _task_run_args << name.to_sym
+
+      # Define getter that pulls from run_with JSON column
+      define_method(name) do
+        return instance_variable_get("@#{name}") if instance_variable_defined?("@#{name}")
+
+        value = run_with&.dig(name.to_s)
+        return unless value
+
+        # Deserialize GID if it's a string starting with gid://
+        deserialized = if value.is_a?(String) && value.start_with?("gid://")
+          begin
+            GlobalID::Locator.locate(value)
+          rescue ActiveRecord::RecordNotFound
+            nil
+          end
+        else
+          value
+        end
+
+        instance_variable_set("@#{name}", deserialized)
+      end
+
+      # Define setter that stores in memory (for use during run)
+      define_method("#{name}=") do |value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    # Backward compatibility alias
+    alias_method :task_run_arg, :run_with
+
+    # Transform run args into a hash that can be stored in the run_with database column
+    def serialize_run_with(args)
+      serialized_args = {}
+      _run_with_args.each do |arg_name|
+        next unless args.key?(arg_name)
+
+        value = args[arg_name]
+        serialized_args[arg_name.to_s] = if value.respond_to?(:to_global_id)
+          value.to_global_id.to_s
+        else
+          value
+        end
+      end
+
+      serialized_args
+    end
+
+    # Backward compatibility alias
+    alias_method :serialize_task_run_args, :serialize_run_with
+  end
+
+private
+
+  # Automatically called before validation on create to serialize run_with args
+  # Collects all declared run_with arguments from instance variables and serializes them
+  # to the run_with JSON column
+  def serialize_run_with_to_column
+    args = {}
+
+    # Collect all run_with args that were set via instance variables
+    self.class._run_with_args.each do |arg_name|
+      if instance_variable_defined?("@#{arg_name}")
+        args[arg_name] = instance_variable_get("@#{arg_name}")
+      end
+    end
+
+    # Merge serialized args into run_with hash if any args were set
+    if args.any?
+      self.run_with ||= {}
+      self.run_with = self.run_with.merge(self.class.serialize_run_with(args))
+    end
+  end
+end

data/app/models/raif/conversation.rb

@@ -1,12 +1,64 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: raif_conversations
+#
+#  id                         :bigint           not null, primary key
+#  available_model_tools      :jsonb            not null
+#  available_user_tools       :jsonb            not null
+#  conversation_entries_count :integer          default(0), not null
+#  creator_type               :string           not null
+#  generating_entry_response  :boolean          default(FALSE), not null
+#  llm_messages_max_length    :integer
+#  llm_model_key              :string           not null
+#  requested_language_key     :string
+#  response_format            :integer          default("text"), not null
+#  source_type                :string
+#  system_prompt              :text
+#  type                       :string           not null
+#  created_at                 :datetime         not null
+#  updated_at                 :datetime         not null
+#  creator_id                 :bigint           not null
+#  source_id                  :bigint
+#
+# Indexes
+#
+#  index_raif_conversations_on_created_at  (created_at)
+#  index_raif_conversations_on_creator     (creator_type,creator_id)
+#  index_raif_conversations_on_source      (source_type,source_id)
+#
 class Raif::Conversation < Raif::ApplicationRecord
+  prepend Raif::Concerns::HasPromptTemplates
+
   include Raif::Concerns::HasLlm
   include Raif::Concerns::HasRequestedLanguage
   include Raif::Concerns::HasAvailableModelTools
   include Raif::Concerns::LlmResponseParsing
+  include Raif::Concerns::LlmPromptCaching
 
   belongs_to :creator, polymorphic: true
+  belongs_to :source, polymorphic: true, optional: true
+
+  class << self
+    def before_prompt_model_for_entry_response(&block)
+      @before_prompt_model_for_entry_response_blocks ||= []
+      @before_prompt_model_for_entry_response_blocks << block if block
+    end
+
+    def before_prompt_model_for_entry_response_blocks
+      blocks = []
+
+      # Collect blocks from ancestors (in reverse order so parent blocks run first)
+      ancestors.reverse_each do |klass|
+        if klass.instance_variable_defined?(:@before_prompt_model_for_entry_response_blocks)
+          blocks.concat(klass.instance_variable_get(:@before_prompt_model_for_entry_response_blocks))
+        end
+      end
+
+      blocks
+    end
+  end
 
   has_many :entries, class_name: "Raif::ConversationEntry", dependent: :destroy, foreign_key: :raif_conversation_id, inverse_of: :raif_conversation
 
@@ -14,6 +66,7 @@ class Raif::Conversation < Raif::ApplicationRecord
 
   after_initialize -> { self.available_model_tools ||= [] }
   after_initialize -> { self.available_user_tools ||= [] }
+  after_initialize -> { self.llm_messages_max_length ||= Raif.config.conversation_llm_messages_max_length_default }
 
   before_validation ->{ self.type ||= "Raif::Conversation" }, on: :create
 
@@ -39,17 +92,33 @@ class Raif::Conversation < Raif::ApplicationRecord
   end
 
   def prompt_model_for_entry_response(entry:, &block)
-    update(system_prompt: build_system_prompt)
+    self.class.before_prompt_model_for_entry_response_blocks.each do |callback_block|
+      instance_exec(entry, &callback_block)
+    end
+
+    self.system_prompt = build_system_prompt
+    self.generating_entry_response = true
+    save!
 
-    llm.chat(
+    model_completion = llm.chat(
       messages: llm_messages,
       source: entry,
       response_format: response_format.to_sym,
       system_prompt: system_prompt,
       available_model_tools: available_model_tools,
+      anthropic_prompt_caching_enabled: self.class.anthropic_prompt_caching_enabled,
+      bedrock_prompt_caching_enabled: self.class.bedrock_prompt_caching_enabled,
       &block
     )
+
+    self.generating_entry_response = false
+    save!
+
+    model_completion
   rescue StandardError => e
+    self.generating_entry_response = false
+    save!
+
     Rails.logger.error("Error processing conversation entry ##{entry.id}. #{e.message}")
     Rails.logger.error(e.backtrace.join("\n"))
 
@@ -75,14 +144,36 @@ class Raif::Conversation < Raif::ApplicationRecord
   def llm_messages
     messages = []
 
-    entries.oldest_first.includes(:raif_model_tool_invocations).each do |entry|
-      messages << { "role" => "user", "content" => entry.user_message } unless entry.user_message.blank?
+    # Apply max length limit to entries if configured (nil means no limit)
+    included_entries = entries.oldest_first.includes(:raif_model_tool_invocations)
+    included_entries = included_entries.last(llm_messages_max_length) if llm_messages_max_length.present?
+
+    included_entries.each do |entry|
+      unless entry.user_message.blank?
+        messages << Raif::Messages::UserMessage.new(content: entry.user_message).to_h
+      end
+
       next unless entry.completed?
 
-      messages << { "role" => "assistant", "content" => entry.model_response_message } unless entry.model_response_message.blank?
-      entry.raif_model_tool_invocations.each do |tool_invocation|
-        messages << { "role" => "assistant", "content" => tool_invocation.as_llm_message }
-        messages << { "role" => "assistant", "content" => tool_invocation.result_llm_message } if tool_invocation.result_llm_message.present?
+      tool_invocations = entry.raif_model_tool_invocations.to_a
+
+      if tool_invocations.any?
+        # First tool call includes the assistant's message (if any).
+        # For the result payload we send the model-facing observation when the tool
+        # opts into observations, while keeping the raw invocation.result persisted
+        # for admin/UI rendering.
+        first_invocation = tool_invocations.shift
+        messages << first_invocation.as_tool_call_message(assistant_message: entry.model_response_message.presence)
+        messages << first_invocation.as_tool_call_result_message(result: tool_result_for_llm(first_invocation))
+
+        # Remaining tool calls (if multiple)
+        tool_invocations.each do |tool_invocation|
+          messages << tool_invocation.as_tool_call_message
+          messages << tool_invocation.as_tool_call_result_message(result: tool_result_for_llm(tool_invocation))
+        end
+      elsif entry.model_response_message.present?
+        # No tool calls, just a regular assistant response
+        messages << Raif::Messages::AssistantMessage.new(content: entry.model_response_message).to_h
       end
     end
 
@@ -93,4 +184,17 @@ class Raif::Conversation < Raif::ApplicationRecord
     available_user_tools.map(&:constantize)
   end
 
+private
+
+  def tool_result_for_llm(tool_invocation)
+    # Some tools persist a compact structured result for display/admin purposes but
+    # need to send richer text/XML back to the model for the continuation turn.
+    return tool_invocation.result unless tool_invocation.triggers_observation_to_model?
+
+    tool = tool_invocation.tool
+    return tool_invocation.result unless tool.respond_to?(:observation_for_invocation)
+
+    tool.observation_for_invocation(tool_invocation).presence || tool_invocation.result
+  end
+
 end

data/app/models/raif/conversation_entry.rb

@@ -1,5 +1,32 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: raif_conversation_entries
+#
+#  id                     :bigint           not null, primary key
+#  completed_at           :datetime
+#  creator_type           :string           not null
+#  failed_at              :datetime
+#  model_response_message :text
+#  raw_response           :text
+#  started_at             :datetime
+#  user_message           :text
+#  created_at             :datetime         not null
+#  updated_at             :datetime         not null
+#  creator_id             :bigint           not null
+#  raif_conversation_id   :bigint           not null
+#
+# Indexes
+#
+#  index_raif_conversation_entries_on_created_at            (created_at)
+#  index_raif_conversation_entries_on_creator               (creator_type,creator_id)
+#  index_raif_conversation_entries_on_raif_conversation_id  (raif_conversation_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (raif_conversation_id => raif_conversations.id)
+#
 class Raif::ConversationEntry < Raif::ApplicationRecord
   include Raif::Concerns::InvokesModelTools
   include Raif::Concerns::HasAvailableModelTools
@@ -32,8 +59,7 @@ class Raif::ConversationEntry < Raif::ApplicationRecord
   def add_user_tool_invocation_to_user_message
     return unless raif_user_tool_invocation.present?
 
-    separator = response_format == "html" ? "<br>" : "\n\n"
-    self.user_message = [user_message, raif_user_tool_invocation.as_user_message].join(separator)
+    self.user_message = [user_message, raif_user_tool_invocation.as_user_message].join("\n\n")
   end
 
   def response_format
@@ -47,7 +73,7 @@ class Raif::ConversationEntry < Raif::ApplicationRecord
   def process_entry!
     self.model_response_message = ""
 
-    self.raif_model_completion = raif_conversation.prompt_model_for_entry_response(entry: self) do |model_completion, _delta, _sse_event|
+    model_completion = raif_conversation.prompt_model_for_entry_response(entry: self) do |model_completion, _delta, _sse_event|
       self.raw_response = model_completion.raw_response
       self.model_response_message = raif_conversation.process_model_response_message(
         message: model_completion.parsed_response(force_reparse: true),
@@ -63,6 +89,10 @@ class Raif::ConversationEntry < Raif::ApplicationRecord
       broadcast_replace_to raif_conversation
     end
 
+    # Failed prompt attempts can still persist a model completion for debugging.
+    # Avoid clearing the has_one association with nil, which would delete that row.
+    self.raif_model_completion = model_completion if model_completion.present?
+
     if raif_model_completion.present? && (raif_model_completion.parsed_response.present? || raif_model_completion.response_tool_calls.present?)
       extract_message_and_invoke_tools!
       create_entry_for_observation! if triggers_observation_to_model?
@@ -98,7 +128,11 @@ private
         tool_klass = available_model_tools_map[tool_call["name"]]
         next if tool_klass.nil?
 
-        tool_klass.invoke_tool(tool_arguments: tool_call["arguments"], source: self)
+        tool_klass.invoke_tool(
+          provider_tool_call_id: tool_call["provider_tool_call_id"],
+          tool_arguments: tool_call["arguments"],
+          source: self
+        )
       end
 
       completed!

data/app/models/raif/embedding_model.rb

@@ -5,6 +5,7 @@ class Raif::EmbeddingModel
 
   attr_accessor :key,
     :api_name,
+    :display_name,
     :input_token_cost,
     :default_output_vector_size
 
@@ -13,7 +14,7 @@ class Raif::EmbeddingModel
   validates :key, presence: true
 
   def name
-    I18n.t("raif.embedding_model_names.#{key}")
+    I18n.t("raif.embedding_model_names.#{key}", default: display_name || key.to_s.humanize)
   end
 
   def generate_embedding!(input, dimensions: nil)

data/app/models/raif/embedding_models/bedrock.rb

@@ -29,6 +29,15 @@ private
   end
 
   def bedrock_client
-    @bedrock_client ||= Aws::BedrockRuntime::Client.new(region: Raif.config.aws_bedrock_region)
+    @bedrock_client ||= begin
+      client_options = {
+        region: Raif.config.aws_bedrock_region
+      }
+
+      client_options[:http_read_timeout] = Raif.config.request_read_timeout if Raif.config.request_read_timeout
+      client_options[:http_open_timeout] = Raif.config.request_open_timeout if Raif.config.request_open_timeout
+
+      Aws::BedrockRuntime::Client.new(client_options)
+    end
   end
 end

data/app/models/raif/embedding_models/google.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Raif::EmbeddingModels::Google < Raif::EmbeddingModel
+  def generate_embedding!(input, dimensions: nil)
+    unless input.is_a?(String)
+      raise ArgumentError, "Raif::EmbeddingModels::Google#generate_embedding! input must be a string"
+    end
+
+    response = connection.post("models/#{api_name}:embedContent") do |req|
+      req.body = build_request_parameters(input, dimensions:)
+    end
+
+    response.body.dig("embedding", "values")
+  end
+
+private
+
+  def build_request_parameters(input, dimensions: nil)
+    params = {
+      content: {
+        parts: [{ text: input }]
+      }
+    }
+
+    params[:outputDimensionality] = dimensions if dimensions.present?
+    params
+  end
+
+  def connection
+    @connection ||= Faraday.new(url: "https://generativelanguage.googleapis.com/v1beta", request: Raif.default_request_options) do |f|
+      f.headers["x-goog-api-key"] = Raif.config.google_api_key
+      f.request :json
+      f.response :json
+      f.response :raise_error
+    end
+  end
+end

data/app/models/raif/embedding_models/open_ai.rb

@@ -30,7 +30,7 @@ private
   end
 
   def connection
-    @connection ||= Faraday.new(url: "https://api.openai.com/v1") do |f|
+    @connection ||= Faraday.new(url: Raif.config.open_ai_embedding_base_url, request: Raif.default_request_options) do |f|
       f.headers["Authorization"] = "Bearer #{Raif.config.open_ai_api_key}"
       f.request :json
       f.response :json