Class: Riffer::Messages::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/riffer/messages/base.rb,
sig/generated/riffer/messages/base.rbs

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

Parameters:

  • (String)
  • id: (String, nil) (defaults to: nil) 


60
61
62
63
 
# File 'lib/riffer/messages/base.rb', line 60

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

Instance Attribute Details

#content ⇒ String (readonly)

The message content.

Returns:

  • (String) 


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

def content
  @content
end

#id ⇒ String? (readonly)

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

Returns:

  • (String, nil) 


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

def id
  @id
end

Class Method Details

.from_hash(msg) ⇒ Riffer::Messages::Base

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

Parameters:

Returns:



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
49
50
 
# File 'lib/riffer/messages/base.rb', line 12

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

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

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

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

  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 do |tc|
      tc.is_a?(Riffer::Messages::Assistant::ToolCall) ? tc : Riffer::Messages::Assistant::ToolCall.new(**tc)
    end
    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) ⇒ Riffer::Messages::Base

Merges another same-role message into this one. Tool messages are never merged.

: (untyped) -> Riffer::Messages::Base

Parameters:

  • (Object)

Returns:



94
95
96
 
# File 'lib/riffer/messages/base.rb', line 94

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

#generate_id ⇒ String?

: () -> String?

Returns:

  • (String, nil) 


101
102
103
104
105
106
 
# File 'lib/riffer/messages/base.rb', line 101

def generate_id
  case Riffer.config.message_id_strategy
  when :uuid then SecureRandom.uuid
  when :uuidv7 then SecureRandom.uuid_v7
  end
end

#has_tool_calls? ⇒ Boolean

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

: () -> bool

Returns:

  • (Boolean) 


86
87
88
 
# File 'lib/riffer/messages/base.rb', line 86

def has_tool_calls?
  false
end

#role ⇒ Symbol

Returns the message role.

: () -> Symbol

Returns:

  • (Symbol) 


78
79
80
 
# File 'lib/riffer/messages/base.rb', line 78

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

#to_h ⇒ Hash[Symbol, untyped]

Converts the message to a hash.

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

Returns:

  • (Hash[Symbol, untyped]) 


69
70
71
72
73
 
# File 'lib/riffer/messages/base.rb', line 69

def to_h
  hash = { role: role, content: content }
  hash[:id] = id if id
  hash
end