A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
module DiscourseAi
class AiApiAuditLogResponseDecoder
MAX_INPUT_BYTES = 1.megabyte
MAX_EVENTS = 10_000
def self.decode(raw_response_payload, truncated: false)
new(raw_response_payload, truncated:).decode
end
def initialize(raw_response_payload, truncated:)
@raw_response_payload = raw_response_payload
@truncated = truncated
@stream_terminated = false
@reasoning_fragments = []
@answer_fragments = []
end
def decode
return if invalid_input?
events = parse_events
return if events.nil?
details =
DiscourseAi::AiApiAuditLogStreamDetailsExtractor.extract(
events,
stream_terminated: @stream_terminated,
)
return if details.invalid?
events.each { |event| extract_fragments(event) }
{
"thinking" => @reasoning_fragments.join.presence,
"tool_calls" => details.tool_calls.presence,
"tool_results" => details.tool_results.presence,
"response" => @answer_fragments.join.presence,
}.compact.presence
rescue JSON::ParserError, TypeError, ArgumentError
nil
end
private
def invalid_input?
@truncated || !@raw_response_payload.is_a?(String) || @raw_response_payload.blank? ||
!@raw_response_payload.valid_encoding? || @raw_response_payload.bytesize > MAX_INPUT_BYTES
end
def parse_events
if sse_transport?
parse_sse
else
parse_newline_delimited_json
end
end
def sse_transport?
@raw_response_payload.each_line.any? do |line|
line.match?(/\A(?:data|event):/) || line.start_with?(":")
end
end
def parse_sse
events = []
record_lines = []
done = false
valid = true
@raw_response_payload.each_line do |line|
line = line.chomp
if line.empty?
parsed_record = parse_sse_record(record_lines)
if parsed_record == :invalid
valid = false
break
end
if parsed_record == :done
done = true
elsif parsed_record
if done || events.length >= MAX_EVENTS
valid = false
break
end
events << parsed_record
end
record_lines = []
else
record_lines << line
end
end
return if !valid || record_lines.present?
@stream_terminated = done
return if events.empty?
events
end
def parse_sse_record(lines)
return if lines.empty?
data_lines = []
lines.each do |line|
next if line.start_with?(":")
field, value = line.split(":", 2)
return :invalid if value.nil? || !%w[data event].include?(field)
value = value.delete_prefix(" ")
data_lines << value if field == "data"
end
return if data_lines.empty?
data = data_lines.join("\n")
return :done if data.strip == "[DONE]"
parsed = JSON.parse(data)
parsed.is_a?(Hash) ? parsed : :invalid
end
def parse_newline_delimited_json
events = []
valid = true
@raw_response_payload.each_line do |line|
line = line.chomp
next if line.blank?
if events.length >= MAX_EVENTS
valid = false
break
end
event = JSON.parse(line)
if !event.is_a?(Hash)
valid = false
break
end
events << event
end
return if !valid || events.length < 2
events
end
def extract_fragments(event)
extract_open_ai_chat(event)
extract_open_ai_response(event)
extract_anthropic(event)
extract_gemini(event)
extract_gemini_interaction(event)
extract_ollama(event)
extract_cohere(event)
end
def extract_open_ai_chat(event)
choices = event["choices"]
return if !choices.is_a?(Array)
choices.each do |choice|
delta = choice.is_a?(Hash) ? choice["delta"] : nil
next if !delta.is_a?(Hash)
reasoning =
if delta["reasoning"].is_a?(String)
delta["reasoning"]
elsif delta["reasoning_content"].is_a?(String)
delta["reasoning_content"]
end
append(@reasoning_fragments, reasoning)
append(@answer_fragments, delta["content"])
end
end
def extract_open_ai_response(event)
case event["type"]
when "response.reasoning_summary_text.delta"
append(@reasoning_fragments, event["delta"])
when "response.output_text.delta"
append(@answer_fragments, event["delta"])
end
end
def extract_anthropic(event)
case event["type"]
when "content_block_start"
content_block = event["content_block"]
return if !content_block.is_a?(Hash)
case content_block["type"]
when "thinking"
append(@reasoning_fragments, content_block["thinking"])
when "text"
append(@answer_fragments, content_block["text"])
end
when "content_block_delta"
delta = event["delta"]
return if !delta.is_a?(Hash)
case delta["type"]
when "thinking_delta"
append(@reasoning_fragments, delta["thinking"])
when "text_delta"
append(@answer_fragments, delta["text"])
end
end
end
def extract_gemini(event)
candidates = event["candidates"]
return if !candidates.is_a?(Array)
candidates.each do |candidate|
parts = candidate.is_a?(Hash) ? candidate.dig("content", "parts") : nil
next if !parts.is_a?(Array)
parts.each do |part|
next if !part.is_a?(Hash)
fragments = part["thought"] == true ? @reasoning_fragments : @answer_fragments
append(fragments, part["text"])
end
end
end
def extract_gemini_interaction(event)
return if event["event_type"] != "step.delta"
delta = event["delta"]
return if !delta.is_a?(Hash)
case delta["type"]
when "thought_summary"
content = delta["content"]
append(@reasoning_fragments, content["text"]) if content.is_a?(Hash)
when "text"
append(@answer_fragments, delta["text"])
end
end
def extract_ollama(event)
message = event["message"]
return if !message.is_a?(Hash)
append(@reasoning_fragments, message["thinking"])
append(@answer_fragments, message["content"])
end
def extract_cohere(event)
case event["event_type"]
when "text-generation"
append(@answer_fragments, event["text"])
when "tool-calls-generation"
append(@reasoning_fragments, event["text"])
end
end
def append(fragments, value)
fragments << value if value.is_a?(String) && !value.empty?
end
end
end