raif 1.3.0 → 1.5.0

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::HasRuntimeDuration
+  extend ActiveSupport::Concern
+
+  def runtime_ended_at
+    completed_at || failed_at
+  end
+
+  def runtime_duration_seconds
+    return if started_at.blank? || runtime_ended_at.blank?
+
+    duration_in_seconds = runtime_ended_at - started_at
+    return if duration_in_seconds.negative?
+
+    duration_in_seconds
+  end
+
+  def runtime_duration
+    duration_in_seconds = runtime_duration_seconds
+    return "-" if duration_in_seconds.nil?
+
+    if duration_in_seconds < 1
+      "#{(duration_in_seconds * 1000).round}ms"
+    elsif duration_in_seconds < 60
+      seconds = (duration_in_seconds * 100).round / 100.0
+      "#{seconds.to_s.sub(/\.0+\z/, "").sub(/(\.\d*[1-9])0+\z/, "\\1")}s"
+    else
+      total_seconds = duration_in_seconds.round
+      hours = total_seconds / 3600
+      minutes = (total_seconds % 3600) / 60
+      seconds = total_seconds % 60
+
+      parts = []
+      parts << "#{hours}h" if hours.positive?
+      parts << "#{minutes}m" if minutes.positive? || hours.positive?
+      parts << "#{seconds}s"
+      parts.join(" ")
+    end
+  end
+end

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

@@ -6,22 +6,70 @@ module Raif
       extend ActiveSupport::Concern
 
       class_methods do
-        def json_schema_definition(schema_name, &block)
+        def json_schema_definition(schema_name, dynamic: false, &block)
           raise ArgumentError, "A block must be provided to define the JSON schema" unless block_given?
 
-          @schemas ||= {}
-          @schemas[schema_name] = Raif::JsonSchemaBuilder.new
-          @schemas[schema_name].instance_eval(&block)
-          @schemas[schema_name]
+          # Check if block expects an instance parameter (arity == 1)
+          # arity == 0: no parameters (class-level schema)
+          # arity == 1: one parameter (instance-dependent schema)
+          if block.arity == 1
+            # Store block for instance-dependent schema building
+            @schema_blocks ||= {}
+            @schema_blocks[schema_name] = block
+          elsif dynamic
+            # Store block for class-level dynamic schema (re-evaluated each call)
+            @dynamic_schema_blocks ||= {}
+            @dynamic_schema_blocks[schema_name] = block
+          else
+            # Build schema immediately for class-level (backward compatible)
+            @schemas ||= {}
+            @schemas[schema_name] = Raif::JsonSchemaBuilder.new
+            @schemas[schema_name].instance_eval(&block)
+          end
         end
 
         def schema_defined?(schema_name)
-          @schemas&.dig(schema_name).present?
+          @schemas&.dig(schema_name).present? ||
+            @schema_blocks&.dig(schema_name).present? ||
+            @dynamic_schema_blocks&.dig(schema_name).present?
         end
 
         def schema_for(schema_name)
+          # Check if this is an instance-dependent schema
+          if @schema_blocks&.dig(schema_name).present?
+            raise Raif::Errors::InstanceDependentSchemaError,
+              "The schema '#{schema_name}' is instance-dependent and cannot be accessed at the class level. " \
+                "Call this method on an instance instead."
+          end
+
+          # Check if this is a dynamic schema (re-evaluate each call)
+          if @dynamic_schema_blocks&.dig(schema_name).present?
+            builder = Raif::JsonSchemaBuilder.new
+            builder.instance_eval(&@dynamic_schema_blocks[schema_name])
+            return builder.to_schema
+          end
+
           @schemas[schema_name].to_schema
         end
+
+        def instance_dependent_schema?(schema_name)
+          @schema_blocks&.dig(schema_name).present?
+        end
+      end
+
+      # Instance method to build schema with instance context
+      def schema_for_instance(schema_name)
+        block = self.class.instance_variable_get(:@schema_blocks)&.[](schema_name)
+
+        if block
+          # Build schema with instance context
+          builder = Raif::JsonSchemaBuilder.new
+          builder.build_with_instance(self, &block)
+          builder.to_schema
+        elsif self.class.schema_defined?(schema_name)
+          # Fall back to class-level schema (handles both static and dynamic)
+          self.class.schema_for(schema_name)
+        end
       end
     end
   end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::LlmPromptCaching
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :anthropic_prompt_caching_enabled, instance_writer: false, default: false
+    class_attribute :bedrock_prompt_caching_enabled, instance_writer: false, default: false
+  end
+
+  class_methods do
+    def enable_anthropic_prompt_caching
+      self.anthropic_prompt_caching_enabled = true
+    end
+
+    def enable_bedrock_prompt_caching
+      self.bedrock_prompt_caching_enabled = true
+    end
+  end
+end

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

@@ -3,6 +3,12 @@
 module Raif::Concerns::Llms::Anthropic::MessageFormatting
   extend ActiveSupport::Concern
 
+  def format_messages(messages)
+    # Anthropic tool results come back as user-role content blocks, so conversation
+    # continuations may need adjacent user messages collapsed after formatting.
+    consolidate_consecutive_role_messages(super, content_key: "content")
+  end
+
   def format_model_image_input_message(image_input)
     if image_input.source_type == :url
       {
@@ -48,4 +54,32 @@ module Raif::Concerns::Llms::Anthropic::MessageFormatting
       raise Raif::Errors::InvalidModelFileInputError, "Invalid model file input source type: #{file_input.source_type}"
     end
   end
+
+  def format_tool_call_message(tool_call)
+    content_array = []
+    content_array << format_string_message(tool_call["assistant_message"]) if tool_call["assistant_message"].present?
+
+    content_array << {
+      "type" => "tool_use",
+      "id" => tool_call["provider_tool_call_id"],
+      "name" => tool_call["name"],
+      "input" => tool_call["arguments"]
+    }
+
+    {
+      "role" => "assistant",
+      "content" => content_array
+    }
+  end
+
+  def format_tool_call_result_message(tool_call_result)
+    {
+      "role" => "user",
+      "content" => [{
+        "type" => "tool_result",
+        "tool_use_id" => tool_call_result["provider_tool_call_id"],
+        "content" => 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/anthropic/response_tool_calls.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Anthropic::ResponseToolCalls
+  extend ActiveSupport::Concern
+
+  def extract_response_tool_calls(resp)
+    return if resp&.dig("content").nil?
+
+    # Find any tool_use content blocks
+    tool_uses = resp&.dig("content")&.select do |content|
+      content["type"] == "tool_use"
+    end
+
+    return if tool_uses.blank?
+
+    tool_uses.map do |tool_use|
+      {
+        "provider_tool_call_id" => tool_use["id"],
+        "name" => tool_use["name"],
+        "arguments" => tool_use["input"],
+      }
+    end
+  end
+end

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

@@ -53,4 +53,12 @@ module Raif::Concerns::Llms::Anthropic::ToolFormatting
         "Invalid provider-managed tool: #{tool.name} for #{key}"
     end
   end
+
+  def build_forced_tool_choice(tool_name)
+    { "type" => "tool", "name" => tool_name, "disable_parallel_tool_use" => true }
+  end
+
+  def build_required_tool_choice
+    { "type" => "any", "disable_parallel_tool_use" => true }
+  end
 end

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

@@ -3,6 +3,13 @@
 module Raif::Concerns::Llms::Bedrock::MessageFormatting
   extend ActiveSupport::Concern
 
+  def format_messages(messages)
+    # Bedrock tool results are represented as user-role content blocks, so a
+    # tool_result followed by the next user prompt must be merged into one user
+    # message before sending it to the provider.
+    consolidate_consecutive_role_messages(super, content_key: "content")
+  end
+
   def format_string_message(content, role: nil)
     { "text" => content }
   end
@@ -67,4 +74,40 @@ module Raif::Concerns::Llms::Bedrock::MessageFormatting
       "text/markdown" => "md"
     }[content_type]
   end
+
+  def format_tool_call_message(tool_call)
+    content_array = []
+    content_array << format_string_message(tool_call["assistant_message"]) if tool_call["assistant_message"].present?
+
+    content_array << {
+      "tool_use" => {
+        "tool_use_id" => tool_call["provider_tool_call_id"],
+        "name" => tool_call["name"],
+        "input" => tool_call["arguments"]
+      }
+    }
+
+    {
+      "role" => "assistant",
+      "content" => content_array
+    }
+  end
+
+  def format_tool_call_result_message(tool_call_result)
+    tool_result_content = if tool_call_result["result"].is_a?(String)
+      { "text" => tool_call_result["result"] }
+    else
+      { "json" => tool_call_result["result"] }
+    end
+
+    {
+      "role" => "user",
+      "content" => [{
+        "tool_result" => {
+          "tool_use_id" => tool_call_result["provider_tool_call_id"],
+          "content" => [tool_result_content]
+        }
+      }]
+    }
+  end
 end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Bedrock::ResponseToolCalls
+  extend ActiveSupport::Concern
+
+  def extract_response_tool_calls(resp)
+    # Get the message from the response object
+    message = resp.output.message
+    return if message.content.nil?
+
+    # Find any tool_use blocks in the content array
+    tool_uses = message.content.select do |content|
+      content.respond_to?(:tool_use) && content.tool_use.present?
+    end
+
+    return if tool_uses.blank?
+
+    tool_uses.map do |content|
+      {
+        "provider_tool_call_id" => content.tool_use.tool_use_id,
+        "name" => content.tool_use.name,
+        "arguments" => content.tool_use.input
+      }
+    end
+  end
+end

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

@@ -34,4 +34,12 @@ module Raif::Concerns::Llms::Bedrock::ToolFormatting
       tools: tools.map{|tool| { tool_spec: tool } }
     }
   end
+
+  def build_forced_tool_choice(tool_name)
+    { tool: { name: tool_name } }
+  end
+
+  def build_required_tool_choice
+    { any: {} }
+  end
 end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Google::MessageFormatting
+  extend ActiveSupport::Concern
+
+  # Google uses a different envelope ("parts") and also represents tool results as
+  # user-role messages, so we normalize adjacent same-role messages after formatting.
+  def format_messages(messages)
+    formatted_messages = messages.map do |message|
+      if message.is_a?(Hash) && message["type"] == "tool_call"
+        format_tool_call_message(message)
+      elsif message.is_a?(Hash) && message["type"] == "tool_call_result"
+        format_tool_call_result_message(message)
+      else
+        role = message["role"] || message[:role]
+        # Google uses "model" instead of "assistant"
+        google_role = role == "assistant" ? "model" : role
+        {
+          "role" => google_role,
+          "parts" => format_message_content(message["content"] || message[:content], role: role)
+        }
+      end
+    end
+
+    consolidate_consecutive_role_messages(formatted_messages, content_key: "parts")
+  end
+
+  def format_string_message(content, role: nil)
+    { "text" => content }
+  end
+
+  def format_model_image_input_message(image_input)
+    if image_input.source_type == :url
+      {
+        "fileData" => {
+          "mimeType" => image_input.content_type,
+          "fileUri" => image_input.url
+        }
+      }
+    elsif image_input.source_type == :file_content
+      {
+        "inlineData" => {
+          "mimeType" => image_input.content_type,
+          "data" => image_input.base64_data
+        }
+      }
+    else
+      raise Raif::Errors::InvalidModelImageInputError, "Invalid model image input source type: #{image_input.source_type}"
+    end
+  end
+
+  def format_model_file_input_message(file_input)
+    if file_input.source_type == :url
+      {
+        "fileData" => {
+          "mimeType" => file_input.content_type,
+          "fileUri" => file_input.url
+        }
+      }
+    elsif file_input.source_type == :file_content
+      {
+        "inlineData" => {
+          "mimeType" => file_input.content_type,
+          "data" => file_input.base64_data
+        }
+      }
+    else
+      raise Raif::Errors::InvalidModelFileInputError, "Invalid model file input source type: #{file_input.source_type}"
+    end
+  end
+
+  def format_tool_call_message(tool_call)
+    parts = []
+
+    if tool_call["assistant_message"].present?
+      parts << format_string_message(tool_call["assistant_message"])
+    end
+
+    function_call_part = {
+      "functionCall" => {
+        "name" => tool_call["name"],
+        "args" => tool_call["arguments"]
+      }
+    }
+
+    # Include thoughtSignature if present (required for Gemini 2.5+ thinking models)
+    thought_signature = tool_call.dig("provider_metadata", "thought_signature")
+    function_call_part["thoughtSignature"] = thought_signature if thought_signature.present?
+
+    parts << function_call_part
+
+    {
+      "role" => "model",
+      "parts" => parts
+    }
+  end
+
+  def format_tool_call_result_message(tool_call_result)
+    result = tool_call_result["result"]
+    response_content = result.is_a?(String) ? { "output" => result } : result
+
+    {
+      "role" => "user",
+      "parts" => [{
+        "functionResponse" => {
+          "name" => tool_call_result["name"],
+          "response" => response_content
+        }
+      }]
+    }
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Google::ResponseToolCalls
+  extend ActiveSupport::Concern
+
+  def extract_response_tool_calls(resp)
+    parts = resp&.dig("candidates", 0, "content", "parts")
+    return if parts.blank?
+
+    # Find any functionCall parts
+    function_calls = parts.select { |part| part.key?("functionCall") }
+
+    return if function_calls.blank?
+
+    function_calls.map do |part|
+      function_call = part["functionCall"]
+      tool_call = {
+        # Google doesn't provide a unique ID for function calls, so we generate one
+        "provider_tool_call_id" => SecureRandom.uuid,
+        "name" => function_call["name"],
+        "arguments" => function_call["args"]
+      }
+
+      # Capture thoughtSignature if present (required for Gemini 2.5+ thinking models)
+      if part["thoughtSignature"].present?
+        tool_call["provider_metadata"] = { "thought_signature" => part["thoughtSignature"] }
+      end
+
+      tool_call
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::Google::ToolFormatting
+  extend ActiveSupport::Concern
+
+  def build_tools_parameter(model_completion)
+    tools = []
+    function_declarations = []
+
+    # If we support native tool use and have tools available, add them to the request
+    if supports_native_tool_use? && model_completion.available_model_tools.any?
+      model_completion.available_model_tools_map.each do |_tool_name, tool|
+        if tool.provider_managed?
+          # Provider-managed tools are added as separate tool entries
+          tools << format_provider_managed_tool(tool)
+        else
+          function_declarations << {
+            name: tool.tool_name,
+            description: tool.tool_description,
+            parameters: sanitize_schema_for_google(tool.tool_arguments_schema)
+          }
+        end
+      end
+    end
+
+    # Add function declarations if any
+    if function_declarations.any?
+      tools << { functionDeclarations: function_declarations }
+    end
+
+    tools
+  end
+
+  def format_provider_managed_tool(tool)
+    validate_provider_managed_tool_support!(tool)
+
+    case tool.name
+    when "Raif::ModelTools::ProviderManaged::WebSearch"
+      { google_search: {} }
+    when "Raif::ModelTools::ProviderManaged::CodeExecution"
+      { code_execution: {} }
+    else
+      raise Raif::Errors::UnsupportedFeatureError,
+        "Invalid provider-managed tool: #{tool.name} for #{key}"
+    end
+  end
+
+  def build_forced_tool_choice(tool_name)
+    { mode: "ANY", allowedFunctionNames: [tool_name] }
+  end
+
+  def build_required_tool_choice
+    { mode: "ANY" }
+  end
+
+private
+
+  # Google's API doesn't support additionalProperties in JSON schemas
+  # This method recursively removes it from the schema
+  def sanitize_schema_for_google(schema)
+    return schema unless schema.is_a?(Hash)
+
+    sanitized = schema.except(:additionalProperties, "additionalProperties")
+
+    sanitized.transform_values do |value|
+      case value
+      when Hash
+        sanitize_schema_for_google(value)
+      when Array
+        value.map { |item| sanitize_schema_for_google(item) }
+      else
+        value
+      end
+    end
+  end
+end

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

@@ -5,11 +5,17 @@ module Raif::Concerns::Llms::MessageFormatting
 
   def format_messages(messages)
     messages.map do |message|
-      role = message["role"] || message[:role]
-      {
-        "role" => role,
-        "content" => format_message_content(message["content"] || message[:content], role: role)
-      }
+      if message.is_a?(Hash) && message["type"] == "tool_call"
+        format_tool_call_message(message)
+      elsif message.is_a?(Hash) && message["type"] == "tool_call_result"
+        format_tool_call_result_message(message)
+      else
+        role = message["role"] || message[:role]
+        {
+          "role" => role,
+          "content" => format_message_content(message["content"] || message[:content], role: role)
+        }
+      end
     end
   end
 
@@ -39,4 +45,34 @@ module Raif::Concerns::Llms::MessageFormatting
     { "type" => "text", "text" => content }
   end
 
+  def consolidate_consecutive_role_messages(messages, content_key:)
+    # Bedrock, Anthropic, and Google all model tool results as normal role-based
+    # message content blocks. After formatting, a tool result can therefore be a
+    # "user" message immediately followed by the next user turn. Those providers
+    # expect alternating roles, so their adapters collapse adjacent same-role blocks.
+    return messages if messages.size <= 1
+
+    messages.each_with_object([]) do |message, consolidated|
+      candidate = message.deep_dup
+      previous_message = consolidated.last
+
+      if mergeable_consecutive_role_messages?(previous_message, candidate, content_key:)
+        previous_message[content_key] += candidate[content_key]
+      else
+        consolidated << candidate
+      end
+    end
+  end
+
+private
+
+  def mergeable_consecutive_role_messages?(previous_message, message, content_key:)
+    previous_message.is_a?(Hash) &&
+      message.is_a?(Hash) &&
+      previous_message["role"].present? &&
+      previous_message["role"] == message["role"] &&
+      previous_message[content_key].is_a?(Array) &&
+      message[content_key].is_a?(Array)
+  end
+
 end

data/app/models/raif/concerns/llms/open_ai/json_schema_validation.rb

@@ -23,7 +23,7 @@ module Raif::Concerns::Llms::OpenAi::JsonSchemaValidation
       # Check properties count (max 100 total)
       validate_properties_count(schema, errors)
 
-      # Check nesting depth (max 5 levels)
+      # Check nesting depth (max 10 levels)
       validate_nesting_depth(schema, errors)
 
       # Check for unsupported anyOf at root level
@@ -118,8 +118,8 @@ private
   def validate_nesting_depth(schema, errors, depth = 1)
     return unless schema.is_a?(Hash)
 
-    if depth > 5
-      errors << "Schema exceeds maximum nesting depth of 5 levels"
+    if depth > 10
+      errors << "Schema exceeds maximum nesting depth of 10 levels"
       return
     end
 

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

@@ -38,4 +38,26 @@ module Raif::Concerns::Llms::OpenAiCompletions::MessageFormatting
       raise Raif::Errors::InvalidModelFileInputError, "Invalid model image input source type: #{file_input.source_type}"
     end
   end
+
+  def format_tool_call_message(tool_call)
+    {
+      "role" => "assistant",
+      "tool_calls" => [{
+        "id" => tool_call["provider_tool_call_id"],
+        "type" => "function",
+        "function" => {
+          "name" => tool_call["name"],
+          "arguments" => JSON.generate(tool_call["arguments"])
+        }
+      }]
+    }
+  end
+
+  def format_tool_call_result_message(tool_call_result)
+    {
+      "role" => "tool",
+      "tool_call_id" => tool_call_result["provider_tool_call_id"],
+      "content" => 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_completions/response_tool_calls.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Raif::Concerns::Llms::OpenAiCompletions::ResponseToolCalls
+  extend ActiveSupport::Concern
+
+  def extract_response_tool_calls(resp)
+    tool_calls = resp&.dig("choices", 0, "message", "tool_calls")
+    return if tool_calls.blank?
+
+    tool_calls.map do |tool_call|
+      {
+        "provider_tool_call_id" => tool_call["id"],
+        "name" => tool_call["function"]["name"],
+        "arguments" => begin
+          JSON.parse(tool_call["function"]["arguments"])
+        rescue JSON::ParserError
+          tool_call["function"]["arguments"]
+        end
+      }
+    end
+  end
+end

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

@@ -23,4 +23,12 @@ module Raif::Concerns::Llms::OpenAiCompletions::ToolFormatting
       end
     end
   end
+
+  def build_forced_tool_choice(tool_name)
+    { "type" => "function", "function" => { "name" => tool_name } }
+  end
+
+  def build_required_tool_choice
+    "required"
+  end
 end