Class: Raif::Conversation

Inherits:
ApplicationRecord show all
Includes:
Raif::Concerns::HasAvailableModelTools, Raif::Concerns::HasLlm, Raif::Concerns::HasPromptTemplates, Raif::Concerns::HasRequestedLanguage, Raif::Concerns::LlmResponseParsing
Defined in:
app/models/raif/conversation.rb

Overview

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)

Constant Summary

Constants included from Raif::Concerns::LlmResponseParsing

Raif::Concerns::LlmResponseParsing::ASCII_CONTROL_CHARS

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Raif::Concerns::LlmResponseParsing

#parse_html_response, #parse_json_response, #parsed_response

Methods included from Raif::Concerns::HasAvailableModelTools

#available_model_tools_map

Methods included from Raif::Concerns::HasRequestedLanguage

#requested_language_name, #system_prompt_language_preference

Methods included from Raif::Concerns::HasLlm

#default_llm_model_key, #llm

Methods included from Raif::Concerns::HasPromptTemplates

#build_prompt

Methods inherited from ApplicationRecord

table_name_prefix, where_json_not_blank

Class Method Details

.before_prompt_model_for_entry_response(&block) ⇒ Object 



43
44
45
46
 
# File 'app/models/raif/conversation.rb', line 43

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

.before_prompt_model_for_entry_response_blocks ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'app/models/raif/conversation.rb', line 48

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

Instance Method Details

#available_user_tool_classes ⇒ Object 



180
181
182
 
# File 'app/models/raif/conversation.rb', line 180

def available_user_tool_classes
  available_user_tools.map(&:constantize)
end

#build_system_prompt ⇒ Object 



72
73
74
75
76
77
 
# File 'app/models/raif/conversation.rb', line 72

def build_system_prompt
  <<~PROMPT.strip
    #{system_prompt_intro}
    #{system_prompt_language_preference}
  PROMPT
end

#initial_chat_message ⇒ Object

i18n-tasks-use t(‘raif.conversation.initial_chat_message’)



85
86
87
 
# File 'app/models/raif/conversation.rb', line 85

def initial_chat_message
  I18n.t("#{self.class.name.underscore.gsub("/", ".")}.initial_chat_message")
end

#initial_chat_message_partial_path ⇒ Object 



89
90
91
 
# File 'app/models/raif/conversation.rb', line 89

def initial_chat_message_partial_path
  "raif/conversations/initial_chat_message"
end

#llm_messages ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'app/models/raif/conversation.rb', line 141

def llm_messages
  messages = []

  # 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?

    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

  messages
end

#process_model_response_message(message:, entry:) ⇒ Object 



135
136
137
138
139
 
# File 'app/models/raif/conversation.rb', line 135

def process_model_response_message(message:, entry:)
  # no-op by default.
  # Override in subclasses for type-specific processing of the model response message
  message
end

#prompt_model_for_entry_response(entry:, &block) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'app/models/raif/conversation.rb', line 93

def prompt_model_for_entry_response(entry:, &block)
  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!

  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,
    &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"))

  entry.failed!

  if defined?(Airbrake)
    notice = Airbrake.build_notice(e)
    notice[:context][:component] = "raif_conversation"
    notice[:context][:action] = "prompt_model_for_entry_response"

    Airbrake.notify(notice)
  end

  nil
end

#system_prompt_intro ⇒ Object 



79
80
81
82
 
# File 'app/models/raif/conversation.rb', line 79

def system_prompt_intro
  sp = Raif.config.conversation_system_prompt_intro
  sp.respond_to?(:call) ? sp.call(self) : sp
end