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



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

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

Instance Attribute Details

#content ⇒ Object (readonly)

The message content.



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

def content
  @content
end

#id ⇒ Object (readonly)

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



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

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
 
# 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]
    Riffer::Messages::Assistant.new(content, id: id, tool_calls: tool_calls, structured_output: structured_output)
  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) 


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

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) 


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

def has_tool_calls?
  false
end

#role ⇒ Object

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

Raises:

  • (NotImplementedError) 


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

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

#to_h ⇒ Object

Converts the message to a hash.

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



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

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