Class: Riffer::Messages::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/riffer/messages/base.rb

Overview

Base class for all message types. Subclasses must implement role.

Direct Known Subclasses

Assistant, System, Tool, User

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(content, id: nil) ⇒ Base

– : (String, ?id: String?) -> void



58
59
60
61
 
# File 'lib/riffer/messages/base.rb', line 58

def initialize(content, id: nil)
  @content = content
  @id = id || generate_id
end

Instance Attribute Details

#content ⇒ Object (readonly)

The message content.



51
52
53
 
# File 'lib/riffer/messages/base.rb', line 51

def content
  @content
end

#id ⇒ Object (readonly)

The message id, or nil when Riffer.config.message_id_strategy is :none.



54
55
56
 
# File 'lib/riffer/messages/base.rb', line 54

def id
  @id
end

Class Method Details

.from_hash(msg) ⇒ Object

Builds the matching message subclass from a hash, or returns msg unchanged when it is already a message. Raises Riffer::ArgumentError on an invalid message. – : ((Hash[Symbol, untyped] | Riffer::Messages::Base)) -> Riffer::Messages::Base



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/riffer/messages/base.rb', line 12

def self.from_hash(msg)
  return msg if msg.is_a?(Riffer::Messages::Base)

  unless msg.is_a?(Hash)
    raise Riffer::ArgumentError, "Message must be a Hash or Message object, got #{msg.class}"
  end

  role = msg[:role]
  content = msg[:content]

  if role.nil? || role.empty?
    raise Riffer::ArgumentError, "Message hash must include a 'role' key"
  end

  id = msg[:id]

  case role.to_sym
  when :user
    files = (msg[:files] || []).map { |f| Riffer::Messages::FilePart.from_hash(f) }
    Riffer::Messages::User.new(content, id: id, files: files)
  when :assistant
    tool_calls = (msg[:tool_calls] || []).map { |tc|
      tc.is_a?(Riffer::Messages::Assistant::ToolCall) ? tc : Riffer::Messages::Assistant::ToolCall.new(**tc)
    }
    structured_output = msg[:structured_output]
    finish_reason = msg[:finish_reason]&.to_sym
    Riffer::Messages::Assistant.new(content, id: id, tool_calls: tool_calls, structured_output: structured_output, finish_reason: finish_reason)
  when :system
    Riffer::Messages::System.new(content, id: id)
  when :tool
    tool_call_id = msg[:tool_call_id]
    name = msg[:name]
    Riffer::Messages::Tool.new(content, id: id, tool_call_id: tool_call_id, name: name)
  else
    raise Riffer::ArgumentError, "Unknown message role: #{role}"
  end
end

Instance Method Details

#+(other) ⇒ Object

Merges another same-role message into this one. Tool messages are never merged. – : (untyped) -> Riffer::Messages::Base

Raises:

  • (NotImplementedError) 


92
93
94
 
# File 'lib/riffer/messages/base.rb', line 92

def +(other)
  raise NotImplementedError, "Subclasses must implement #+"
end

#has_tool_calls? ⇒ Boolean

Whether this message carries pending tool calls (overridden by Riffer::Messages::Assistant). – : () -> bool

Returns:

  • (Boolean) 


84
85
86
 
# File 'lib/riffer/messages/base.rb', line 84

def has_tool_calls?
  false
end

#role ⇒ Object

Returns the message role. – : () -> Symbol

Raises:

  • (NotImplementedError) 


76
77
78
 
# File 'lib/riffer/messages/base.rb', line 76

def role
  raise NotImplementedError, "Subclasses must implement #role"
end

#to_h ⇒ Object

Converts the message to a hash.

– : () -> Hash[Symbol, untyped]



67
68
69
70
71
 
# File 'lib/riffer/messages/base.rb', line 67

def to_h
  hash = {role: role, content: content}
  hash[:id] = id unless id.nil?
  hash
end