riffer 0.54.0 → 0.56.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.claude/rules/rbs-inline.md +6 -6
- data/.release-please-manifest.json +1 -1
- data/.ruby-version +1 -1
- data/CHANGELOG.md +46 -0
- data/README.md +26 -1
- data/Steepfile +2 -2
- data/UPGRADING.md +3 -0
- data/docs/AGENTS.md +37 -12
- data/docs/AGENT_LIFECYCLE.md +1 -1
- data/docs/CATALOG.md +8 -8
- data/docs/CONFIGURATION.md +95 -17
- data/docs/GUARDRAILS.md +2 -0
- data/docs/MCP.md +3 -4
- data/docs/MESSAGES.md +112 -15
- data/docs/STABILITY.md +32 -0
- data/docs/STREAM_EVENTS.md +17 -1
- data/docs/TESTING.md +22 -1
- data/docs/TOOLS.md +11 -11
- data/docs/TRACING.md +1 -1
- data/docs/providers/AMAZON_BEDROCK.md +3 -1
- data/docs/providers/ANTHROPIC.md +44 -44
- data/docs/providers/CUSTOM_PROVIDERS.md +59 -0
- data/docs/providers/GEMINI.md +76 -26
- data/docs/providers/GOOGLE_CLOUD.md +363 -0
- data/docs/providers/MOCK_PROVIDER.md +2 -0
- data/docs/providers/OPENAI.md +3 -1
- data/docs/providers/PROVIDERS.md +30 -18
- data/docs-site/manifest.yml +6 -0
- data/lib/riffer/agent/run.rb +28 -13
- data/lib/riffer/agent/session.rb +33 -10
- data/lib/riffer/agent/structured_output.rb +6 -1
- data/lib/riffer/config/anthropic.rb +9 -0
- data/lib/riffer/config/future.rb +53 -0
- data/lib/riffer/config/gemini.rb +9 -0
- data/lib/riffer/config/google_cloud.rb +38 -0
- data/lib/riffer/config/pricing.rb +5 -15
- data/lib/riffer/config.rb +19 -0
- data/lib/riffer/deprecation/event.rb +25 -0
- data/lib/riffer/deprecation.rb +60 -0
- data/lib/riffer/http/client.rb +141 -0
- data/lib/riffer/http.rb +5 -0
- data/lib/riffer/mcp/client.rb +0 -1
- data/lib/riffer/messages/assistant/server_tool_part.rb +73 -0
- data/lib/riffer/messages/assistant/text_part.rb +52 -0
- data/lib/riffer/messages/assistant.rb +64 -17
- data/lib/riffer/params/any_of.rb +37 -9
- data/lib/riffer/params/param.rb +35 -14
- data/lib/riffer/params.rb +34 -19
- data/lib/riffer/providers/amazon_bedrock.rb +38 -5
- data/lib/riffer/providers/anthropic/client.rb +49 -0
- data/lib/riffer/providers/anthropic.rb +19 -452
- data/lib/riffer/providers/anthropic_compatible/messages_api/stream.rb +219 -0
- data/lib/riffer/providers/anthropic_compatible/messages_api.rb +315 -0
- data/lib/riffer/providers/anthropic_compatible.rb +5 -0
- data/lib/riffer/providers/anthropic_vertex.rb +66 -0
- data/lib/riffer/providers/base.rb +19 -13
- data/lib/riffer/providers/gemini/client.rb +17 -85
- data/lib/riffer/providers/gemini.rb +213 -81
- data/lib/riffer/providers/google_cloud/client.rb +106 -0
- data/lib/riffer/providers/google_cloud.rb +99 -0
- data/lib/riffer/providers/open_ai.rb +21 -16
- data/lib/riffer/providers/repository.rb +2 -0
- data/lib/riffer/stream_events/server_tool_done.rb +21 -0
- data/lib/riffer/testing.rb +6 -0
- data/lib/riffer/version.rb +1 -1
- data/lib/riffer/wire/sse.rb +51 -0
- data/lib/riffer/wire.rb +31 -0
- data/lib/riffer.rb +20 -0
- data/rbs_collection.lock.yaml +24 -4
- data/sig/_private/faraday.rbs +8 -0
- data/sig/_private/googleauth.rbs +7 -0
- data/sig/generated/riffer/agent/run.rbs +5 -0
- data/sig/generated/riffer/agent/session.rbs +6 -0
- data/sig/generated/riffer/config/anthropic.rbs +6 -0
- data/sig/generated/riffer/config/future.rbs +29 -0
- data/sig/generated/riffer/config/gemini.rbs +6 -0
- data/sig/generated/riffer/config/google_cloud.rbs +28 -0
- data/sig/generated/riffer/config/pricing.rbs +0 -9
- data/sig/generated/riffer/config.rbs +10 -0
- data/sig/generated/riffer/deprecation/event.rbs +17 -0
- data/sig/generated/riffer/deprecation.rbs +27 -0
- data/sig/generated/riffer/http/client.rbs +59 -0
- data/sig/generated/riffer/http.rbs +4 -0
- data/sig/generated/riffer/messages/assistant/server_tool_part.rbs +44 -0
- data/sig/generated/riffer/messages/assistant/text_part.rbs +35 -0
- data/sig/generated/riffer/messages/assistant.rbs +24 -11
- data/sig/generated/riffer/params/any_of.rbs +13 -5
- data/sig/generated/riffer/params/param.rbs +10 -5
- data/sig/generated/riffer/params.rbs +8 -4
- data/sig/generated/riffer/providers/amazon_bedrock.rbs +14 -2
- data/sig/generated/riffer/providers/anthropic/client.rbs +34 -0
- data/sig/generated/riffer/providers/anthropic.rbs +5 -124
- data/sig/generated/riffer/providers/anthropic_compatible/messages_api/stream.rbs +81 -0
- data/sig/generated/riffer/providers/anthropic_compatible/messages_api.rbs +108 -0
- data/sig/generated/riffer/providers/anthropic_compatible.rbs +4 -0
- data/sig/generated/riffer/providers/anthropic_vertex.rbs +45 -0
- data/sig/generated/riffer/providers/base.rbs +5 -0
- data/sig/generated/riffer/providers/gemini/client.rbs +11 -34
- data/sig/generated/riffer/providers/gemini.rbs +66 -4
- data/sig/generated/riffer/providers/google_cloud/client.rbs +71 -0
- data/sig/generated/riffer/providers/google_cloud.rbs +64 -0
- data/sig/generated/riffer/providers/open_ai.rbs +7 -2
- data/sig/generated/riffer/stream_events/server_tool_done.rbs +15 -0
- data/sig/generated/riffer/testing.rbs +4 -0
- data/sig/generated/riffer/wire/sse.rbs +23 -0
- data/sig/generated/riffer/wire.rbs +17 -0
- data/sig/generated/riffer.rbs +15 -0
- data/sig/manual/riffer/deprecation.rbs +5 -0
- data/sig/manual/riffer/providers/anthropic_compatible/messages_api.rbs +8 -0
- data/sig/manual/riffer/providers/gemini.rbs +8 -0
- data/sig/manual/riffer/providers/google_cloud.rbs +8 -0
- data/sig/manual/riffer/wire.rbs +5 -0
- metadata +76 -5
- data/sig/_private/anthropic.rbs +0 -17
- data/sig/_private/riffer/providers/anthropic.rbs +0 -6
- data/sig/_private/riffer/providers/gemini.rbs +0 -7
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
# rbs_inline: enabled
|
|
3
|
+
|
|
4
|
+
# A call or result of a tool the provider ran itself (e.g. web search). Stored and replayed
|
|
5
|
+
# verbatim under the same rule as reasoning parts: only the adapter whose +format+ it is sends
|
|
6
|
+
# it back.
|
|
7
|
+
class Riffer::Messages::Assistant::ServerToolPart
|
|
8
|
+
KINDS = %i[call result].freeze #: Array[Symbol]
|
|
9
|
+
|
|
10
|
+
attr_reader :name #: String # @dynamic name
|
|
11
|
+
attr_reader :kind #: Symbol # @dynamic kind
|
|
12
|
+
|
|
13
|
+
# The provider's block, JSON-encoded and unchanged.
|
|
14
|
+
attr_reader :data #: String # @dynamic data
|
|
15
|
+
|
|
16
|
+
# Shared by a call and its result.
|
|
17
|
+
attr_reader :id #: String? # @dynamic id
|
|
18
|
+
|
|
19
|
+
attr_reader :format #: String? # @dynamic format
|
|
20
|
+
|
|
21
|
+
#--
|
|
22
|
+
#: ((Hash[Symbol, untyped] | Riffer::Messages::Assistant::ServerToolPart)) -> Riffer::Messages::Assistant::ServerToolPart
|
|
23
|
+
def self.from_hash(part)
|
|
24
|
+
return part if part.is_a?(Riffer::Messages::Assistant::ServerToolPart)
|
|
25
|
+
|
|
26
|
+
new(
|
|
27
|
+
name: part[:name],
|
|
28
|
+
kind: part[:kind].to_sym,
|
|
29
|
+
data: part[:data],
|
|
30
|
+
id: part[:id],
|
|
31
|
+
format: part[:format],
|
|
32
|
+
)
|
|
33
|
+
end
|
|
34
|
+
|
|
35
|
+
#--
|
|
36
|
+
#: (name: String, kind: Symbol, data: String, ?id: String?, ?format: String?) -> void
|
|
37
|
+
def initialize(name:, kind:, data:, id: nil, format: nil)
|
|
38
|
+
unless KINDS.include?(kind)
|
|
39
|
+
raise Riffer::ArgumentError,
|
|
40
|
+
"kind must be one of #{KINDS.inspect}, got #{kind.inspect}"
|
|
41
|
+
end
|
|
42
|
+
|
|
43
|
+
@name = name
|
|
44
|
+
@kind = kind
|
|
45
|
+
@data = data
|
|
46
|
+
@id = id
|
|
47
|
+
@format = format
|
|
48
|
+
end
|
|
49
|
+
|
|
50
|
+
#--
|
|
51
|
+
#: () -> Hash[Symbol, untyped]
|
|
52
|
+
def to_h
|
|
53
|
+
{ name: name, kind: kind, data: data, id: id, format: format }.compact
|
|
54
|
+
end
|
|
55
|
+
|
|
56
|
+
#--
|
|
57
|
+
#: (untyped) -> bool
|
|
58
|
+
def ==(other)
|
|
59
|
+
other.is_a?(Riffer::Messages::Assistant::ServerToolPart) && to_h == other.to_h
|
|
60
|
+
end
|
|
61
|
+
|
|
62
|
+
#--
|
|
63
|
+
#: (untyped) -> bool
|
|
64
|
+
def eql?(other)
|
|
65
|
+
self == other
|
|
66
|
+
end
|
|
67
|
+
|
|
68
|
+
#--
|
|
69
|
+
#: () -> Integer
|
|
70
|
+
def hash
|
|
71
|
+
to_h.hash
|
|
72
|
+
end
|
|
73
|
+
end
|
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
# rbs_inline: enabled
|
|
3
|
+
|
|
4
|
+
class Riffer::Messages::Assistant::TextPart
|
|
5
|
+
attr_reader :text #: String # @dynamic text
|
|
6
|
+
|
|
7
|
+
# The provider's whole block as JSON, kept when it carries more than the text (e.g. Anthropic
|
|
8
|
+
# +citations+), so the adapter that produced it can send it back unchanged.
|
|
9
|
+
attr_reader :data #: String? # @dynamic data
|
|
10
|
+
|
|
11
|
+
attr_reader :format #: String? # @dynamic format
|
|
12
|
+
|
|
13
|
+
#--
|
|
14
|
+
#: ((Hash[Symbol, untyped] | Riffer::Messages::Assistant::TextPart)) -> Riffer::Messages::Assistant::TextPart
|
|
15
|
+
def self.from_hash(part)
|
|
16
|
+
return part if part.is_a?(Riffer::Messages::Assistant::TextPart)
|
|
17
|
+
|
|
18
|
+
new(part[:text].to_s, data: part[:data], format: part[:format])
|
|
19
|
+
end
|
|
20
|
+
|
|
21
|
+
#--
|
|
22
|
+
#: (String, ?data: String?, ?format: String?) -> void
|
|
23
|
+
def initialize(text, data: nil, format: nil)
|
|
24
|
+
@text = text
|
|
25
|
+
@data = data
|
|
26
|
+
@format = format
|
|
27
|
+
end
|
|
28
|
+
|
|
29
|
+
#--
|
|
30
|
+
#: () -> Hash[Symbol, untyped]
|
|
31
|
+
def to_h
|
|
32
|
+
{ text: text, data: data, format: format }.compact
|
|
33
|
+
end
|
|
34
|
+
|
|
35
|
+
#--
|
|
36
|
+
#: (untyped) -> bool
|
|
37
|
+
def ==(other)
|
|
38
|
+
other.is_a?(Riffer::Messages::Assistant::TextPart) && to_h == other.to_h
|
|
39
|
+
end
|
|
40
|
+
|
|
41
|
+
#--
|
|
42
|
+
#: (untyped) -> bool
|
|
43
|
+
def eql?(other)
|
|
44
|
+
self == other
|
|
45
|
+
end
|
|
46
|
+
|
|
47
|
+
#--
|
|
48
|
+
#: () -> Integer
|
|
49
|
+
def hash
|
|
50
|
+
to_h.hash
|
|
51
|
+
end
|
|
52
|
+
end
|
|
@@ -5,6 +5,13 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
|
|
|
5
5
|
# The other reasoning part types carry no prose.
|
|
6
6
|
REASONING_TEXT_TYPES = %i[text summary].freeze #: Array[Symbol]
|
|
7
7
|
|
|
8
|
+
PART_TAGS = {
|
|
9
|
+
Riffer::Messages::Assistant::TextPart => :text,
|
|
10
|
+
Riffer::Messages::Assistant::ReasoningPart => :reasoning,
|
|
11
|
+
Riffer::Messages::Assistant::ToolCall => :tool_call,
|
|
12
|
+
Riffer::Messages::Assistant::ServerToolPart => :server_tool,
|
|
13
|
+
}.freeze #: Hash[singleton(Riffer::Messages::Assistant::TextPart) | singleton(Riffer::Messages::Assistant::ReasoningPart) | singleton(Riffer::Messages::Assistant::ToolCall) | singleton(Riffer::Messages::Assistant::ServerToolPart), Symbol]
|
|
14
|
+
|
|
8
15
|
#--
|
|
9
16
|
#: ((Hash[Symbol, untyped] | Riffer::Messages::Assistant)) -> Riffer::Messages::Assistant
|
|
10
17
|
def self.from_hash(msg)
|
|
@@ -13,6 +20,7 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
|
|
|
13
20
|
new(
|
|
14
21
|
msg[:content],
|
|
15
22
|
id: msg[:id],
|
|
23
|
+
parts: msg[:parts]&.map { |part| part_from_hash(part) },
|
|
16
24
|
tool_calls: (msg[:tool_calls] || []).map { |tc| Riffer::Messages::Assistant::ToolCall.from_hash(tc) },
|
|
17
25
|
reasoning: (msg[:reasoning] || []).map { |part| Riffer::Messages::Assistant::ReasoningPart.from_hash(part) },
|
|
18
26
|
token_usage: msg[:token_usage] && Riffer::Providers::TokenUsage.from_hash(msg[:token_usage]),
|
|
@@ -22,6 +30,24 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
|
|
|
22
30
|
)
|
|
23
31
|
end
|
|
24
32
|
|
|
33
|
+
#--
|
|
34
|
+
#: ((Hash[Symbol, untyped] | Riffer::Messages::Assistant::TextPart | Riffer::Messages::Assistant::ReasoningPart | Riffer::Messages::Assistant::ToolCall | Riffer::Messages::Assistant::ServerToolPart)) -> (Riffer::Messages::Assistant::TextPart | Riffer::Messages::Assistant::ReasoningPart | Riffer::Messages::Assistant::ToolCall | Riffer::Messages::Assistant::ServerToolPart)
|
|
35
|
+
def self.part_from_hash(part)
|
|
36
|
+
return part unless part.is_a?(Hash)
|
|
37
|
+
|
|
38
|
+
klass = PART_TAGS.key(part[:part]&.to_sym)
|
|
39
|
+
unless klass
|
|
40
|
+
raise Riffer::ArgumentError, "part must be one of #{PART_TAGS.values.inspect}, got #{part[:part].inspect}"
|
|
41
|
+
end
|
|
42
|
+
|
|
43
|
+
klass.from_hash(part.except(:part))
|
|
44
|
+
end
|
|
45
|
+
private_class_method :part_from_hash
|
|
46
|
+
|
|
47
|
+
# The turn in the order the provider produced it. +content+, +tool_calls+ and +reasoning+ are
|
|
48
|
+
# views over it.
|
|
49
|
+
attr_reader :parts #: Array[Riffer::Messages::Assistant::TextPart | Riffer::Messages::Assistant::ReasoningPart | Riffer::Messages::Assistant::ToolCall | Riffer::Messages::Assistant::ServerToolPart] # @dynamic parts
|
|
50
|
+
|
|
25
51
|
attr_reader :tool_calls #: Array[Riffer::Messages::Assistant::ToolCall] # @dynamic tool_calls
|
|
26
52
|
|
|
27
53
|
attr_reader :reasoning #: Array[Riffer::Messages::Assistant::ReasoningPart] # @dynamic reasoning
|
|
@@ -34,20 +60,14 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
|
|
|
34
60
|
|
|
35
61
|
attr_reader :finish_reason_raw #: String? # @dynamic finish_reason_raw
|
|
36
62
|
|
|
63
|
+
# Without +parts:+, the parts are built in a fixed order: reasoning, then the content as one
|
|
64
|
+
# text part, then tool calls.
|
|
37
65
|
#--
|
|
38
|
-
#: (
|
|
39
|
-
# String,
|
|
40
|
-
# ?id: String?,
|
|
41
|
-
# ?tool_calls: Array[Riffer::Messages::Assistant::ToolCall],
|
|
42
|
-
# ?reasoning: Array[Riffer::Messages::Assistant::ReasoningPart],
|
|
43
|
-
# ?token_usage: Riffer::Providers::TokenUsage?,
|
|
44
|
-
# ?structured_output: Hash[Symbol, untyped]?,
|
|
45
|
-
# ?finish_reason: Symbol?,
|
|
46
|
-
# ?finish_reason_raw: String?
|
|
47
|
-
# ) -> void
|
|
66
|
+
#: (?String?, ?id: String?, ?parts: Array[Riffer::Messages::Assistant::TextPart | Riffer::Messages::Assistant::ReasoningPart | Riffer::Messages::Assistant::ToolCall | Riffer::Messages::Assistant::ServerToolPart]?, ?tool_calls: Array[Riffer::Messages::Assistant::ToolCall], ?reasoning: Array[Riffer::Messages::Assistant::ReasoningPart], ?token_usage: Riffer::Providers::TokenUsage?, ?structured_output: Hash[Symbol, untyped]?, ?finish_reason: Symbol?, ?finish_reason_raw: String?) -> void
|
|
48
67
|
def initialize(
|
|
49
|
-
content,
|
|
68
|
+
content = nil,
|
|
50
69
|
id: nil,
|
|
70
|
+
parts: nil,
|
|
51
71
|
tool_calls: [],
|
|
52
72
|
reasoning: [],
|
|
53
73
|
token_usage: nil,
|
|
@@ -60,9 +80,14 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
|
|
|
60
80
|
raise Riffer::ArgumentError, "finish_reason must be one of #{values}, got #{finish_reason.inspect}"
|
|
61
81
|
end
|
|
62
82
|
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
83
|
+
if parts && (content || !tool_calls.empty? || !reasoning.empty?)
|
|
84
|
+
raise Riffer::ArgumentError, "pass either parts: or content, tool_calls: and reasoning:, not both"
|
|
85
|
+
end
|
|
86
|
+
|
|
87
|
+
@parts = parts || default_parts(content, tool_calls, reasoning)
|
|
88
|
+
super(@parts.filter_map { |part| part.text if part.is_a?(Riffer::Messages::Assistant::TextPart) }.join, id: id)
|
|
89
|
+
@tool_calls = @parts.grep(Riffer::Messages::Assistant::ToolCall) #: Array[Riffer::Messages::Assistant::ToolCall]
|
|
90
|
+
@reasoning = @parts.grep(Riffer::Messages::Assistant::ReasoningPart) #: Array[Riffer::Messages::Assistant::ReasoningPart]
|
|
66
91
|
@token_usage = token_usage
|
|
67
92
|
@structured_output = structured_output
|
|
68
93
|
@finish_reason = finish_reason
|
|
@@ -103,6 +128,12 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
|
|
|
103
128
|
#--
|
|
104
129
|
#: (Riffer::Messages::Assistant) -> Riffer::Messages::Assistant
|
|
105
130
|
def +(other)
|
|
131
|
+
unless [self, other].all? { |message| described_by_fields?(message) }
|
|
132
|
+
merged = parts.dup
|
|
133
|
+
merged << Riffer::Messages::Assistant::TextPart.new("\n\n") unless content.empty? || other.content.empty?
|
|
134
|
+
return self.class.new(parts: merged.concat(other.parts))
|
|
135
|
+
end
|
|
136
|
+
|
|
106
137
|
self.class.new(
|
|
107
138
|
"#{content}\n\n#{other.content}",
|
|
108
139
|
tool_calls: tool_calls + other.tool_calls,
|
|
@@ -113,14 +144,30 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
|
|
|
113
144
|
#--
|
|
114
145
|
#: () -> Hash[Symbol, untyped]
|
|
115
146
|
def to_h
|
|
116
|
-
hash = { role: role
|
|
147
|
+
hash = { role: role } #: Hash[Symbol, untyped]
|
|
117
148
|
hash[:id] = id if id
|
|
118
|
-
hash[:
|
|
119
|
-
hash[:reasoning] = reasoning.map(&:to_h) if reasoning?
|
|
149
|
+
hash[:parts] = parts.map { |part| { part: PART_TAGS.fetch(part.class), **part.to_h } }
|
|
120
150
|
hash[:token_usage] = token_usage.to_h if token_usage
|
|
121
151
|
hash[:structured_output] = structured_output if structured_output?
|
|
122
152
|
hash[:finish_reason] = finish_reason if finish_reason
|
|
123
153
|
hash[:finish_reason_raw] = finish_reason_raw if finish_reason_raw
|
|
124
154
|
hash
|
|
125
155
|
end
|
|
156
|
+
|
|
157
|
+
private
|
|
158
|
+
|
|
159
|
+
#--
|
|
160
|
+
#: (String?, Array[Riffer::Messages::Assistant::ToolCall], Array[Riffer::Messages::Assistant::ReasoningPart]) -> Array[Riffer::Messages::Assistant::TextPart | Riffer::Messages::Assistant::ReasoningPart | Riffer::Messages::Assistant::ToolCall | Riffer::Messages::Assistant::ServerToolPart]
|
|
161
|
+
def default_parts(content, tool_calls, reasoning)
|
|
162
|
+
parts = [] #: Array[Riffer::Messages::Assistant::TextPart | Riffer::Messages::Assistant::ReasoningPart | Riffer::Messages::Assistant::ToolCall | Riffer::Messages::Assistant::ServerToolPart]
|
|
163
|
+
parts.concat(reasoning)
|
|
164
|
+
parts << Riffer::Messages::Assistant::TextPart.new(content) unless content.nil? || content.empty?
|
|
165
|
+
parts.concat(tool_calls)
|
|
166
|
+
end
|
|
167
|
+
|
|
168
|
+
#--
|
|
169
|
+
#: (Riffer::Messages::Assistant) -> bool
|
|
170
|
+
def described_by_fields?(message)
|
|
171
|
+
message.parts == default_parts(message.content, message.tool_calls, message.reasoning)
|
|
172
|
+
end
|
|
126
173
|
end
|
data/lib/riffer/params/any_of.rb
CHANGED
|
@@ -2,21 +2,49 @@
|
|
|
2
2
|
# rbs_inline: enabled
|
|
3
3
|
|
|
4
4
|
class Riffer::Params::AnyOf
|
|
5
|
-
|
|
5
|
+
# @rbs @name: Symbol
|
|
6
|
+
|
|
7
|
+
attr_reader :variants #: Array[Riffer::Params | Riffer::Params::Param] # @dynamic variants
|
|
6
8
|
|
|
7
9
|
#--
|
|
8
|
-
#: () -> void
|
|
9
|
-
def initialize
|
|
10
|
+
#: (Symbol) -> void
|
|
11
|
+
def initialize(name)
|
|
12
|
+
@name = name
|
|
10
13
|
@variants = []
|
|
11
14
|
end
|
|
12
15
|
|
|
13
16
|
#--
|
|
14
|
-
#: () ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
|
|
15
|
-
def variant(&block)
|
|
16
|
-
|
|
17
|
+
#: (?Module?, ?description: String?, ?enum: Array[untyped]?, ?format: String?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
|
|
18
|
+
def variant(type = nil, description: nil, enum: nil, format: nil, &block)
|
|
19
|
+
if type
|
|
20
|
+
raise Riffer::ArgumentError, "variant takes a type or a block, not both" if block
|
|
21
|
+
|
|
22
|
+
@variants << primitive(type, description, enum, format)
|
|
23
|
+
elsif block
|
|
24
|
+
if description || enum || format
|
|
25
|
+
raise Riffer::ArgumentError, "description:, enum: and format: only apply to a primitive variant"
|
|
26
|
+
end
|
|
27
|
+
|
|
28
|
+
params = Riffer::Params.new
|
|
29
|
+
params.instance_eval(&block)
|
|
30
|
+
@variants << params
|
|
31
|
+
else
|
|
32
|
+
raise Riffer::ArgumentError, "variant requires a type or a block defining its properties"
|
|
33
|
+
end
|
|
34
|
+
end
|
|
35
|
+
|
|
36
|
+
private
|
|
37
|
+
|
|
38
|
+
#--
|
|
39
|
+
#: (Module, String?, Array[untyped]?, String?) -> Riffer::Params::Param
|
|
40
|
+
def primitive(type, description, enum, format)
|
|
41
|
+
unless Riffer::Params::Param::PRIMITIVE_TYPES.include?(type)
|
|
42
|
+
primitives = Riffer::Params::Param::PRIMITIVE_TYPES.map(&:name).join(", ")
|
|
43
|
+
raise Riffer::ArgumentError, "variant type must be a primitive type (#{primitives}), got #{type}"
|
|
44
|
+
end
|
|
17
45
|
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
46
|
+
Riffer::Params::Param.new(
|
|
47
|
+
name: @name, type: type, required: true, description: description, enum: enum, format: format,
|
|
48
|
+
)
|
|
21
49
|
end
|
|
22
50
|
end
|
data/lib/riffer/params/param.rb
CHANGED
|
@@ -46,12 +46,12 @@ class Riffer::Params::Param
|
|
|
46
46
|
|
|
47
47
|
attr_reader :nested_params #: Riffer::Params? # @dynamic nested_params
|
|
48
48
|
|
|
49
|
-
attr_reader :variants #: Array[Riffer::Params]? # @dynamic variants
|
|
49
|
+
attr_reader :variants #: Array[Riffer::Params | Riffer::Params::Param]? # @dynamic variants
|
|
50
50
|
|
|
51
51
|
#--
|
|
52
52
|
#: (Symbol, Hash[Symbol, untyped], required: bool) -> Riffer::Params::Param
|
|
53
53
|
def self.from_json_schema(name, schema, required:)
|
|
54
|
-
variants = resolve_variants(schema[:anyOf]) if schema.key?(:anyOf)
|
|
54
|
+
variants = resolve_variants(name, schema[:anyOf]) if schema.key?(:anyOf)
|
|
55
55
|
ruby_type = variants ? Riffer::Params::AnyOf : json_type_to_ruby(schema[:type])
|
|
56
56
|
nested = resolve_nested_params(ruby_type, schema)
|
|
57
57
|
item_type, dimensions, items = resolve_typed_items(schema) if ruby_type == Array && !nested
|
|
@@ -72,15 +72,19 @@ class Riffer::Params::Param
|
|
|
72
72
|
end
|
|
73
73
|
|
|
74
74
|
#--
|
|
75
|
-
#: (Array[Hash[Symbol, untyped]]) -> Array[Riffer::Params]
|
|
76
|
-
def self.resolve_variants(branches)
|
|
75
|
+
#: (Symbol, Array[Hash[Symbol, untyped]]) -> Array[Riffer::Params | Riffer::Params::Param]
|
|
76
|
+
def self.resolve_variants(name, branches)
|
|
77
77
|
# Strict schemas add a null branch to optional fields; nullability comes from +required+.
|
|
78
78
|
variants = branches.reject { |branch| branch[:type] == "null" }.map do |branch|
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
79
|
+
if branch[:type] == "object"
|
|
80
|
+
Riffer::Params.from_json_schema(branch)
|
|
81
|
+
elsif PRIMITIVE_TYPES.include?(JSON_TYPE_MAPPINGS[branch[:type]]) && !branch.key?(:anyOf)
|
|
82
|
+
from_json_schema(name, branch, required: true)
|
|
83
|
+
else
|
|
84
|
+
raise Riffer::ArgumentError, "Unsupported anyOf branch: #{branch.to_json}"
|
|
85
|
+
end
|
|
82
86
|
end
|
|
83
|
-
raise Riffer::ArgumentError, "anyOf requires at least two
|
|
87
|
+
raise Riffer::ArgumentError, "anyOf requires at least two branches" if variants.size < 2
|
|
84
88
|
|
|
85
89
|
variants
|
|
86
90
|
end
|
|
@@ -133,13 +137,14 @@ class Riffer::Params::Param
|
|
|
133
137
|
#--
|
|
134
138
|
#: (untyped) -> Module
|
|
135
139
|
def self.json_type_to_ruby(type)
|
|
136
|
-
|
|
137
|
-
JSON_TYPE_MAPPINGS.
|
|
140
|
+
types = Array(type) - ["null"]
|
|
141
|
+
ruby_type = JSON_TYPE_MAPPINGS[types.first] if types.one?
|
|
142
|
+
ruby_type || raise(Riffer::ArgumentError, "Unsupported JSON Schema type: #{type.inspect}")
|
|
138
143
|
end
|
|
139
144
|
private_class_method :json_type_to_ruby
|
|
140
145
|
|
|
141
146
|
#--
|
|
142
|
-
#: (name: Symbol, type: Module, required: bool, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?default: untyped, ?item_type: Module?, ?dimensions: Integer, ?nested_params: Riffer::Params?, ?variants: Array[Riffer::Params]?) -> void
|
|
147
|
+
#: (name: Symbol, type: Module, required: bool, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?default: untyped, ?item_type: Module?, ?dimensions: Integer, ?nested_params: Riffer::Params?, ?variants: Array[Riffer::Params | Riffer::Params::Param]?) -> void
|
|
143
148
|
def initialize(name:, type:, required:, description: nil, enum: nil, format: nil, default: nil, item_type: nil,
|
|
144
149
|
dimensions: 1, nested_params: nil, variants: nil)
|
|
145
150
|
if type == Riffer::Params::AnyOf && variants.nil?
|
|
@@ -158,8 +163,9 @@ class Riffer::Params::Param
|
|
|
158
163
|
@dimensions = dimensions
|
|
159
164
|
@nested_params = nested_params
|
|
160
165
|
@variants = variants
|
|
161
|
-
# Checked here rather than in Params so from_json_schema enforces
|
|
166
|
+
# Checked here rather than in Params so from_json_schema enforces them too.
|
|
162
167
|
validate_format! if format
|
|
168
|
+
validate_variant_order! if variants
|
|
163
169
|
end
|
|
164
170
|
|
|
165
171
|
#--
|
|
@@ -172,7 +178,7 @@ class Riffer::Params::Param
|
|
|
172
178
|
elsif type == Float
|
|
173
179
|
value.is_a?(Numeric)
|
|
174
180
|
elsif type == Riffer::Params::AnyOf
|
|
175
|
-
value.is_a?(Hash)
|
|
181
|
+
Array(variants).any? { |variant| variant.is_a?(Riffer::Params) ? value.is_a?(Hash) : variant.valid_type?(value) }
|
|
176
182
|
else
|
|
177
183
|
value.is_a?(type)
|
|
178
184
|
end
|
|
@@ -181,7 +187,10 @@ class Riffer::Params::Param
|
|
|
181
187
|
#--
|
|
182
188
|
#: () -> String
|
|
183
189
|
def type_name
|
|
184
|
-
|
|
190
|
+
if type == Riffer::Params::AnyOf
|
|
191
|
+
names = Array(variants).map { |variant| variant.is_a?(Riffer::Params) ? "object" : variant.type_name }
|
|
192
|
+
return names.uniq.join(" or ")
|
|
193
|
+
end
|
|
185
194
|
|
|
186
195
|
TYPE_MAPPINGS[type] || type.to_s.downcase
|
|
187
196
|
end
|
|
@@ -253,6 +262,18 @@ class Riffer::Params::Param
|
|
|
253
262
|
@default = Riffer::Helpers::DeepDup.call(source.default)
|
|
254
263
|
end
|
|
255
264
|
|
|
265
|
+
# The first matching variant wins, and a Float variant without an enum accepts any number.
|
|
266
|
+
#--
|
|
267
|
+
#: () -> void
|
|
268
|
+
def validate_variant_order!
|
|
269
|
+
primitives = Array(variants).grep(Riffer::Params::Param) #: Array[Riffer::Params::Param]
|
|
270
|
+
float = primitives.index { |variant| variant.type == Float && variant.enum.nil? }
|
|
271
|
+
integer = primitives.rindex { |variant| variant.type == Integer }
|
|
272
|
+
return unless float && integer && float < integer
|
|
273
|
+
|
|
274
|
+
raise Riffer::ArgumentError, "#{name}: an Integer variant after a Float variant without enum: can never match"
|
|
275
|
+
end
|
|
276
|
+
|
|
256
277
|
#--
|
|
257
278
|
#: () -> void
|
|
258
279
|
def validate_format!
|
data/lib/riffer/params.rb
CHANGED
|
@@ -34,7 +34,7 @@ class Riffer::Params
|
|
|
34
34
|
def required(name, type, description: nil, enum: nil, format: nil, of: nil, &)
|
|
35
35
|
item_type, dimensions = unwrap_of(of)
|
|
36
36
|
nested = build_nested(type, item_type, enum, &) unless type == Riffer::Params::AnyOf
|
|
37
|
-
variants = build_variants(of, enum, &) if type == Riffer::Params::AnyOf
|
|
37
|
+
variants = build_variants(name, of, enum, &) if type == Riffer::Params::AnyOf
|
|
38
38
|
@parameters << Riffer::Params::Param.new(
|
|
39
39
|
name: name,
|
|
40
40
|
type: type,
|
|
@@ -55,7 +55,7 @@ class Riffer::Params
|
|
|
55
55
|
def optional(name, type, description: nil, enum: nil, format: nil, default: nil, of: nil, &)
|
|
56
56
|
item_type, dimensions = unwrap_of(of)
|
|
57
57
|
nested = build_nested(type, item_type, enum, &) unless type == Riffer::Params::AnyOf
|
|
58
|
-
variants = build_variants(of, enum, &) if type == Riffer::Params::AnyOf
|
|
58
|
+
variants = build_variants(name, of, enum, &) if type == Riffer::Params::AnyOf
|
|
59
59
|
@parameters << Riffer::Params::Param.new(
|
|
60
60
|
name: name,
|
|
61
61
|
type: type,
|
|
@@ -90,19 +90,8 @@ class Riffer::Params
|
|
|
90
90
|
next
|
|
91
91
|
end
|
|
92
92
|
|
|
93
|
-
|
|
94
|
-
errors << "#{param.name}
|
|
95
|
-
next
|
|
96
|
-
end
|
|
97
|
-
|
|
98
|
-
# A typed array's enum and format constrain its items, which validate_typed_array checks.
|
|
99
|
-
if param.enum && !param.item_type && !param.enum.include?(value)
|
|
100
|
-
errors << "#{param.name} must be one of: #{param.enum.join(', ')}"
|
|
101
|
-
next
|
|
102
|
-
end
|
|
103
|
-
|
|
104
|
-
if param.format && !param.item_type && !Riffer::Params::Format.valid?(param.format, value)
|
|
105
|
-
errors << "#{param.name} must be a valid #{param.format}"
|
|
93
|
+
if (error = value_error(param, value))
|
|
94
|
+
errors << "#{param.name} #{error}"
|
|
106
95
|
next
|
|
107
96
|
end
|
|
108
97
|
|
|
@@ -185,19 +174,32 @@ class Riffer::Params
|
|
|
185
174
|
end
|
|
186
175
|
|
|
187
176
|
#--
|
|
188
|
-
#: ((Module | Array[untyped])?, Array[untyped]?) ?{ (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> Array[Riffer::Params]
|
|
189
|
-
def build_variants(of, enum, &block)
|
|
177
|
+
#: (Symbol, (Module | Array[untyped])?, Array[untyped]?) ?{ (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> Array[Riffer::Params | Riffer::Params::Param]
|
|
178
|
+
def build_variants(name, of, enum, &block)
|
|
190
179
|
raise Riffer::ArgumentError, "of: cannot be used with AnyOf" if of
|
|
191
180
|
raise Riffer::ArgumentError, "enum: cannot be used with AnyOf" if enum
|
|
192
181
|
raise Riffer::ArgumentError, "AnyOf requires a block defining its variants" unless block
|
|
193
182
|
|
|
194
|
-
any_of = Riffer::Params::AnyOf.new
|
|
183
|
+
any_of = Riffer::Params::AnyOf.new(name)
|
|
195
184
|
any_of.instance_eval(&block)
|
|
196
185
|
raise Riffer::ArgumentError, "AnyOf requires at least two variants" if any_of.variants.size < 2
|
|
197
186
|
|
|
198
187
|
any_of.variants
|
|
199
188
|
end
|
|
200
189
|
|
|
190
|
+
#--
|
|
191
|
+
#: (Riffer::Params::Param, untyped) -> String?
|
|
192
|
+
def value_error(param, value)
|
|
193
|
+
return "must be a #{param.type_name}" unless param.valid_type?(value)
|
|
194
|
+
|
|
195
|
+
# A typed array's enum and format constrain its items, which validate_typed_array checks.
|
|
196
|
+
return "must be one of: #{param.enum.join(', ')}" if param.enum && !param.item_type && !param.enum.include?(value)
|
|
197
|
+
|
|
198
|
+
return unless param.format && !param.item_type && !Riffer::Params::Format.valid?(param.format, value)
|
|
199
|
+
|
|
200
|
+
"must be a valid #{param.format}"
|
|
201
|
+
end
|
|
202
|
+
|
|
201
203
|
#--
|
|
202
204
|
#: (Riffer::Params::Param, untyped, Array[String]) -> untyped
|
|
203
205
|
def validate_nested(param, value, errors)
|
|
@@ -229,13 +231,26 @@ class Riffer::Params
|
|
|
229
231
|
end
|
|
230
232
|
|
|
231
233
|
#--
|
|
232
|
-
#: (Riffer::Params::Param,
|
|
234
|
+
#: (Riffer::Params::Param, untyped, Array[String]) -> untyped
|
|
233
235
|
def validate_any_of(param, value, errors)
|
|
234
236
|
variants = param.variants
|
|
235
237
|
return value unless variants
|
|
236
238
|
|
|
237
239
|
variant_errors = [] #: Array[String]
|
|
238
240
|
variants.each.with_index(1) do |variant, number|
|
|
241
|
+
if variant.is_a?(Riffer::Params::Param)
|
|
242
|
+
error = value_error(variant, value)
|
|
243
|
+
return coerce_value(variant.type, value) unless error
|
|
244
|
+
|
|
245
|
+
variant_errors << "variant #{number} (#{error})"
|
|
246
|
+
next
|
|
247
|
+
end
|
|
248
|
+
|
|
249
|
+
unless value.is_a?(Hash)
|
|
250
|
+
variant_errors << "variant #{number} (must be a object)"
|
|
251
|
+
next
|
|
252
|
+
end
|
|
253
|
+
|
|
239
254
|
validated = variant.validate(value)
|
|
240
255
|
# Each variant's schema sets additionalProperties: false on every object
|
|
241
256
|
# it declares, so a key outside this variant rules it out.
|
|
@@ -428,7 +428,8 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
|
|
|
428
428
|
item_id: tool_call[:id],
|
|
429
429
|
call_id: tool_call[:id],
|
|
430
430
|
name: tool_call[:name],
|
|
431
|
-
|
|
431
|
+
# Converse streams no input delta for a call without arguments.
|
|
432
|
+
arguments: tool_call[:arguments].empty? ? "{}" : tool_call[:arguments],
|
|
432
433
|
)
|
|
433
434
|
state[:tool_call] = nil
|
|
434
435
|
end
|
|
@@ -445,6 +446,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
|
|
|
445
446
|
def partition_messages(messages)
|
|
446
447
|
system_prompts = [] #: Array[Hash[Symbol, untyped]]
|
|
447
448
|
conversation_messages = [] #: Array[Hash[Symbol, untyped]]
|
|
449
|
+
document_names = [] #: Array[String]
|
|
448
450
|
|
|
449
451
|
messages.each do |message|
|
|
450
452
|
case message
|
|
@@ -452,7 +454,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
|
|
|
452
454
|
system_prompts << { text: message.content }
|
|
453
455
|
when Riffer::Messages::User
|
|
454
456
|
content = [{ text: message.content }]
|
|
455
|
-
message.files.each { |file| content << convert_file_part_to_bedrock_format(file) }
|
|
457
|
+
message.files.each { |file| content << convert_file_part_to_bedrock_format(file, document_names) }
|
|
456
458
|
conversation_messages << { role: "user", content: content }
|
|
457
459
|
when Riffer::Messages::Assistant
|
|
458
460
|
conversation_messages << convert_assistant_to_bedrock_format(message)
|
|
@@ -515,9 +517,11 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
|
|
|
515
517
|
end
|
|
516
518
|
end
|
|
517
519
|
|
|
520
|
+
# +document_names+ collects the names already used in the request, which
|
|
521
|
+
# Converse requires to be unique across every message.
|
|
518
522
|
#--
|
|
519
|
-
#: (Riffer::Messages::User::FilePart) -> Hash[Symbol, untyped]
|
|
520
|
-
def convert_file_part_to_bedrock_format(file)
|
|
523
|
+
#: (Riffer::Messages::User::FilePart, Array[String]) -> Hash[Symbol, untyped]
|
|
524
|
+
def convert_file_part_to_bedrock_format(file, document_names)
|
|
521
525
|
format = bedrock_format(file.media_type)
|
|
522
526
|
|
|
523
527
|
source = file.data_bytes ? { bytes: file.data_bytes } : { s3_location: { uri: file.url } }
|
|
@@ -525,10 +529,39 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
|
|
|
525
529
|
if file.image?
|
|
526
530
|
{ image: { format: format, source: source } }
|
|
527
531
|
else
|
|
528
|
-
{ document: { format: format, name: file.filename, source: source } }
|
|
532
|
+
{ document: { format: format, name: document_name(file.filename, document_names), source: source } }
|
|
529
533
|
end
|
|
530
534
|
end
|
|
531
535
|
|
|
536
|
+
DOCUMENT_NAME_LIMIT = 200 #: Integer
|
|
537
|
+
private_constant :DOCUMENT_NAME_LIMIT
|
|
538
|
+
|
|
539
|
+
# Converse allows only alphanumerics, single whitespace, hyphens, parentheses
|
|
540
|
+
# and square brackets in a document name, up to 200 characters, so
|
|
541
|
+
# +invoice.pdf+ is sent as +invoice+ and a repeated name gets a counter:
|
|
542
|
+
# +invoice (2)+.
|
|
543
|
+
#--
|
|
544
|
+
#: (String?, Array[String]) -> String
|
|
545
|
+
def document_name(filename, document_names)
|
|
546
|
+
filename = filename.to_s
|
|
547
|
+
base = File.basename(filename, File.extname(filename)).
|
|
548
|
+
gsub(/[^A-Za-z0-9\s\-()\[\]]+/, "-").
|
|
549
|
+
gsub(/\s+/, " ").
|
|
550
|
+
gsub(/\A[\s-]+|[\s-]+\z/, "")
|
|
551
|
+
base = "document" if base.empty?
|
|
552
|
+
|
|
553
|
+
head = base[0, DOCUMENT_NAME_LIMIT] #: String
|
|
554
|
+
name = head.rstrip
|
|
555
|
+
count = 1
|
|
556
|
+
while document_names.include?(name)
|
|
557
|
+
suffix = " (#{count += 1})"
|
|
558
|
+
head = base[0, DOCUMENT_NAME_LIMIT - suffix.length] #: String
|
|
559
|
+
name = "#{head.rstrip}#{suffix}"
|
|
560
|
+
end
|
|
561
|
+
document_names << name
|
|
562
|
+
name
|
|
563
|
+
end
|
|
564
|
+
|
|
532
565
|
BEDROCK_FORMAT_MAP = {
|
|
533
566
|
"image/jpeg" => "jpeg",
|
|
534
567
|
"image/png" => "png",
|
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
# rbs_inline: enabled
|
|
3
|
+
|
|
4
|
+
class Riffer::Providers::Anthropic::Client < Riffer::HTTP::Client
|
|
5
|
+
# @rbs @api_key: String
|
|
6
|
+
# @rbs @base_url: String
|
|
7
|
+
|
|
8
|
+
DEFAULT_BASE_URL = "https://api.anthropic.com" #: String
|
|
9
|
+
|
|
10
|
+
# Override with an anthropic-version entry in +headers+.
|
|
11
|
+
DEFAULT_ANTHROPIC_VERSION = "2026-10-21" #: String
|
|
12
|
+
|
|
13
|
+
#--
|
|
14
|
+
#: (api_key: String, ?base_url: String, ?headers: Hash[String, String], ?connection: Faraday::Connection?) -> void
|
|
15
|
+
def initialize(api_key:, base_url: DEFAULT_BASE_URL, headers: {}, connection: nil)
|
|
16
|
+
super(headers: headers, connection: connection)
|
|
17
|
+
@api_key = api_key
|
|
18
|
+
@base_url = base_url.chomp("/")
|
|
19
|
+
end
|
|
20
|
+
|
|
21
|
+
private
|
|
22
|
+
|
|
23
|
+
#--
|
|
24
|
+
#: (String) -> String
|
|
25
|
+
def url_for(path)
|
|
26
|
+
"#{@base_url}/#{path}"
|
|
27
|
+
end
|
|
28
|
+
|
|
29
|
+
#--
|
|
30
|
+
#: () -> Hash[String, String]
|
|
31
|
+
def headers
|
|
32
|
+
{ "authorization" => "Bearer #{@api_key}", "anthropic-version" => DEFAULT_ANTHROPIC_VERSION }
|
|
33
|
+
end
|
|
34
|
+
|
|
35
|
+
#--
|
|
36
|
+
#: () -> String
|
|
37
|
+
def error_label
|
|
38
|
+
"Anthropic"
|
|
39
|
+
end
|
|
40
|
+
|
|
41
|
+
#--
|
|
42
|
+
#: (Hash[Symbol, untyped], String) -> String
|
|
43
|
+
def error_message(parsed, raw)
|
|
44
|
+
error = parsed[:error]
|
|
45
|
+
return super unless error.is_a?(Hash) && error[:type] && error[:message]
|
|
46
|
+
|
|
47
|
+
"#{error[:type]}: #{error[:message]}"
|
|
48
|
+
end
|
|
49
|
+
end
|