riffer 0.56.0 → 0.57.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/.release-please-manifest.json +1 -1
- data/CHANGELOG.md +19 -0
- data/README.md +1 -1
- data/docs/AGENTS.md +105 -50
- data/docs/AGENT_LIFECYCLE.md +1 -1
- data/docs/CONFIGURATION.md +7 -3
- data/docs/EVALS.md +2 -0
- data/docs/MCP.md +36 -0
- data/docs/MESSAGES.md +13 -0
- data/docs/OVERVIEW.md +7 -7
- data/docs/SERIALIZATION.md +12 -2
- data/docs/SKILLS.md +1 -1
- data/docs/STABILITY.md +1 -1
- data/docs/TOOLS.md +93 -37
- data/docs/TOOL_ADVANCED.md +7 -0
- data/docs/providers/AMAZON_BEDROCK.md +6 -2
- data/docs/providers/ANTHROPIC.md +35 -2
- data/docs/providers/AZURE_OPENAI.md +9 -3
- data/docs/providers/CUSTOM_PROVIDERS.md +19 -0
- data/docs/providers/GEMINI.md +8 -4
- data/docs/providers/GOOGLE_CLOUD.md +9 -4
- data/docs/providers/MOCK_PROVIDER.md +2 -0
- data/docs/providers/OPENAI.md +25 -3
- data/docs/providers/OPENROUTER.md +11 -3
- data/docs/providers/PROVIDERS.md +1 -1
- data/docs-site/index.html.erb +1 -1
- data/lib/riffer/agent/config.rb +21 -0
- data/lib/riffer/agent/context.rb +36 -18
- data/lib/riffer/agent/run.rb +54 -8
- data/lib/riffer/agent/serializer.rb +5 -0
- data/lib/riffer/agent/session.rb +1 -0
- data/lib/riffer/agent.rb +43 -0
- data/lib/riffer/config/mcp.rb +17 -0
- data/lib/riffer/config/pricing.rb +2 -2
- data/lib/riffer/config.rb +12 -1
- data/lib/riffer/evals/evaluator.rb +8 -1
- data/lib/riffer/evals/evaluator_runner.rb +1 -0
- data/lib/riffer/evals/judge.rb +2 -2
- data/lib/riffer/evals.rb +2 -0
- data/lib/riffer/mcp/search_tool.rb +1 -1
- data/lib/riffer/mcp.rb +7 -0
- data/lib/riffer/messages/tool.rb +6 -2
- data/lib/riffer/params/any_of.rb +5 -8
- data/lib/riffer/params/boolean.rb +1 -1
- data/lib/riffer/params/param.rb +96 -67
- data/lib/riffer/params.rb +50 -71
- data/lib/riffer/providers/anthropic_compatible/messages_api/stream.rb +3 -10
- data/lib/riffer/providers/anthropic_compatible/messages_api.rb +88 -12
- data/lib/riffer/providers/base.rb +43 -7
- data/lib/riffer/providers/deferred_tool_gateway/sink.rb +54 -0
- data/lib/riffer/providers/deferred_tool_gateway/tool.rb +17 -0
- data/lib/riffer/providers/deferred_tool_gateway.rb +150 -0
- data/lib/riffer/providers/gemini.rb +5 -5
- data/lib/riffer/providers/mock.rb +6 -0
- data/lib/riffer/providers/open_ai.rb +38 -10
- data/lib/riffer/skills/activate_tool.rb +1 -1
- data/lib/riffer/tool.rb +92 -2
- data/lib/riffer/tools/response.rb +11 -2
- data/lib/riffer/version.rb +1 -1
- data/sig/generated/riffer/agent/config.rbs +13 -1
- data/sig/generated/riffer/agent/context.rbs +16 -0
- data/sig/generated/riffer/agent/run.rbs +14 -2
- data/sig/generated/riffer/agent.rbs +13 -0
- data/sig/generated/riffer/config/mcp.rbs +7 -0
- data/sig/generated/riffer/config.rbs +5 -1
- data/sig/generated/riffer/evals/evaluator.rbs +4 -0
- data/sig/generated/riffer/evals.rbs +1 -0
- data/sig/generated/riffer/mcp.rbs +1 -0
- data/sig/generated/riffer/messages/tool.rbs +4 -2
- data/sig/generated/riffer/params/any_of.rbs +4 -4
- data/sig/generated/riffer/params/boolean.rbs +1 -1
- data/sig/generated/riffer/params/param.rbs +28 -14
- data/sig/generated/riffer/params.rbs +20 -20
- data/sig/generated/riffer/providers/anthropic_compatible/messages_api/stream.rbs +2 -5
- data/sig/generated/riffer/providers/anthropic_compatible/messages_api.rbs +34 -2
- data/sig/generated/riffer/providers/base.rbs +13 -0
- data/sig/generated/riffer/providers/deferred_tool_gateway/sink.rbs +23 -0
- data/sig/generated/riffer/providers/deferred_tool_gateway/tool.rbs +4 -0
- data/sig/generated/riffer/providers/deferred_tool_gateway.rbs +58 -0
- data/sig/generated/riffer/providers/mock.rbs +4 -0
- data/sig/generated/riffer/providers/open_ai.rbs +16 -4
- data/sig/generated/riffer/tool.rbs +48 -2
- data/sig/generated/riffer/tools/response.rbs +9 -2
- data/sig/manual/riffer/providers/deferred_tool_gateway.rbs +5 -0
- metadata +8 -3
- data/lib/riffer/tools/toolable.rb +0 -113
- data/sig/generated/riffer/tools/toolable.rbs +0 -66
data/lib/riffer/params/param.rb
CHANGED
|
@@ -4,31 +4,27 @@
|
|
|
4
4
|
require "json"
|
|
5
5
|
|
|
6
6
|
class Riffer::Params::Param
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
"boolean" => Riffer::Params::Boolean,
|
|
25
|
-
"array" => Array,
|
|
26
|
-
"object" => Hash,
|
|
27
|
-
}.freeze #: Hash[String, Module]
|
|
7
|
+
PRIMITIVE_TYPES = %i[string integer number boolean].freeze #: Array[Symbol]
|
|
8
|
+
|
|
9
|
+
TYPES = [*PRIMITIVE_TYPES, :array, :object, :any_of].freeze #: Array[Symbol]
|
|
10
|
+
|
|
11
|
+
CLASS_TYPES = {
|
|
12
|
+
String => :string,
|
|
13
|
+
Integer => :integer,
|
|
14
|
+
Float => :number,
|
|
15
|
+
Riffer::Params::Boolean => :boolean,
|
|
16
|
+
TrueClass => :boolean,
|
|
17
|
+
FalseClass => :boolean,
|
|
18
|
+
Array => :array,
|
|
19
|
+
Hash => :object,
|
|
20
|
+
Riffer::Params::AnyOf => :any_of,
|
|
21
|
+
}.freeze #: Hash[Module, Symbol]
|
|
22
|
+
|
|
23
|
+
JSON_TYPE_MAPPINGS = (TYPES - [:any_of]).to_h { |type| [type.name, type] }.freeze #: Hash[String, Symbol]
|
|
28
24
|
|
|
29
25
|
attr_reader :name #: Symbol # @dynamic name
|
|
30
26
|
|
|
31
|
-
attr_reader :type #:
|
|
27
|
+
attr_reader :type #: Symbol # @dynamic type
|
|
32
28
|
|
|
33
29
|
attr_reader :required #: bool # @dynamic required
|
|
34
30
|
|
|
@@ -40,7 +36,7 @@ class Riffer::Params::Param
|
|
|
40
36
|
|
|
41
37
|
attr_reader :default #: untyped # @dynamic default
|
|
42
38
|
|
|
43
|
-
attr_reader :item_type #:
|
|
39
|
+
attr_reader :item_type #: Symbol? # @dynamic item_type
|
|
44
40
|
|
|
45
41
|
attr_reader :dimensions #: Integer # @dynamic dimensions
|
|
46
42
|
|
|
@@ -48,17 +44,56 @@ class Riffer::Params::Param
|
|
|
48
44
|
|
|
49
45
|
attr_reader :variants #: Array[Riffer::Params | Riffer::Params::Param]? # @dynamic variants
|
|
50
46
|
|
|
47
|
+
#--
|
|
48
|
+
#: (untyped) -> Symbol?
|
|
49
|
+
def self.resolve_type(type)
|
|
50
|
+
return type if TYPES.include?(type)
|
|
51
|
+
|
|
52
|
+
symbol = CLASS_TYPES[type] #: Symbol?
|
|
53
|
+
return unless symbol
|
|
54
|
+
|
|
55
|
+
Riffer::Deprecation.warn(
|
|
56
|
+
id: :param_class_types,
|
|
57
|
+
message: "#{type.name} as a param type is deprecated and will be removed in a future version, " \
|
|
58
|
+
"not before 1 December 2026; use #{symbol.inspect}.",
|
|
59
|
+
)
|
|
60
|
+
symbol
|
|
61
|
+
end
|
|
62
|
+
|
|
63
|
+
#--
|
|
64
|
+
#: (untyped, String, Array[Symbol]) -> Symbol
|
|
65
|
+
def self.resolve_type!(type, subject, allowed)
|
|
66
|
+
resolved = resolve_type(type)
|
|
67
|
+
return resolved if resolved && allowed.include?(resolved)
|
|
68
|
+
|
|
69
|
+
raise Riffer::ArgumentError, "#{subject} must be one of #{allowed.map(&:inspect).join(', ')}, got #{type.inspect}"
|
|
70
|
+
end
|
|
71
|
+
|
|
72
|
+
#--
|
|
73
|
+
#: (Symbol, untyped) -> bool
|
|
74
|
+
def self.value_of_type?(type, value)
|
|
75
|
+
case type
|
|
76
|
+
when :string then value.is_a?(String)
|
|
77
|
+
when :integer then value.is_a?(Integer)
|
|
78
|
+
when :number then value.is_a?(Numeric)
|
|
79
|
+
when :boolean then [true, false].include?(value)
|
|
80
|
+
when :array then value.is_a?(Array)
|
|
81
|
+
when :object then value.is_a?(Hash)
|
|
82
|
+
else false
|
|
83
|
+
end
|
|
84
|
+
end
|
|
85
|
+
|
|
51
86
|
#--
|
|
52
87
|
#: (Symbol, Hash[Symbol, untyped], required: bool) -> Riffer::Params::Param
|
|
53
88
|
def self.from_json_schema(name, schema, required:)
|
|
54
89
|
variants = resolve_variants(name, schema[:anyOf]) if schema.key?(:anyOf)
|
|
55
|
-
|
|
56
|
-
nested = resolve_nested_params(
|
|
57
|
-
item_type, dimensions, items = resolve_typed_items(schema) if
|
|
90
|
+
type = variants ? :any_of : json_type(schema[:type])
|
|
91
|
+
nested = resolve_nested_params(type, schema)
|
|
92
|
+
item_type, dimensions, items = resolve_typed_items(schema) if type == :array && !nested
|
|
58
93
|
|
|
59
94
|
new(
|
|
60
95
|
name: name,
|
|
61
|
-
type:
|
|
96
|
+
type: type,
|
|
62
97
|
required: required,
|
|
63
98
|
description: schema[:description],
|
|
64
99
|
enum: schema[:enum] || items&.dig(:enum),
|
|
@@ -91,18 +126,18 @@ class Riffer::Params::Param
|
|
|
91
126
|
private_class_method :resolve_variants
|
|
92
127
|
|
|
93
128
|
#--
|
|
94
|
-
#: (
|
|
95
|
-
def self.resolve_nested_params(
|
|
96
|
-
if
|
|
129
|
+
#: (Symbol, Hash[Symbol, untyped]) -> Riffer::Params?
|
|
130
|
+
def self.resolve_nested_params(type, schema)
|
|
131
|
+
if type == :object && schema[:properties]
|
|
97
132
|
Riffer::Params.from_json_schema(schema)
|
|
98
|
-
elsif
|
|
133
|
+
elsif type == :array && schema[:items].is_a?(Hash) && schema[:items][:properties]
|
|
99
134
|
Riffer::Params.from_json_schema(schema[:items])
|
|
100
135
|
end
|
|
101
136
|
end
|
|
102
137
|
private_class_method :resolve_nested_params
|
|
103
138
|
|
|
104
139
|
#--
|
|
105
|
-
#: (Hash[Symbol, untyped]) -> [
|
|
140
|
+
#: (Hash[Symbol, untyped]) -> [Symbol, Integer, Hash[Symbol, untyped]]?
|
|
106
141
|
def self.resolve_typed_items(schema)
|
|
107
142
|
items = schema[:items]
|
|
108
143
|
return unless items.is_a?(Hash)
|
|
@@ -110,7 +145,7 @@ class Riffer::Params::Param
|
|
|
110
145
|
dimensions = 1
|
|
111
146
|
# Riffer only writes nested arrays with enum/format and a single primitive type on the innermost
|
|
112
147
|
# items, and no nullable inner arrays; any other shape would read back with a different meaning.
|
|
113
|
-
while
|
|
148
|
+
while json_type(items[:type]) == :array
|
|
114
149
|
inner = items[:items]
|
|
115
150
|
unless items[:type] == "array" && inner.is_a?(Hash) && !items.keys.intersect?(%i[enum format])
|
|
116
151
|
raise Riffer::ArgumentError, "Unsupported nested array: #{items.to_json}"
|
|
@@ -120,7 +155,7 @@ class Riffer::Params::Param
|
|
|
120
155
|
dimensions += 1
|
|
121
156
|
end
|
|
122
157
|
|
|
123
|
-
item_type =
|
|
158
|
+
item_type = json_type(items[:type])
|
|
124
159
|
if dimensions > 1
|
|
125
160
|
if schema.keys.intersect?(%i[enum format])
|
|
126
161
|
raise Riffer::ArgumentError, "Unsupported nested array: #{schema.to_json}"
|
|
@@ -135,21 +170,19 @@ class Riffer::Params::Param
|
|
|
135
170
|
private_class_method :resolve_typed_items
|
|
136
171
|
|
|
137
172
|
#--
|
|
138
|
-
#: (untyped) ->
|
|
139
|
-
def self.
|
|
173
|
+
#: (untyped) -> Symbol
|
|
174
|
+
def self.json_type(type)
|
|
140
175
|
types = Array(type) - ["null"]
|
|
141
|
-
|
|
142
|
-
|
|
176
|
+
symbol = JSON_TYPE_MAPPINGS[types.first] if types.one?
|
|
177
|
+
symbol || raise(Riffer::ArgumentError, "Unsupported JSON Schema type: #{type.inspect}")
|
|
143
178
|
end
|
|
144
|
-
private_class_method :
|
|
179
|
+
private_class_method :json_type
|
|
145
180
|
|
|
146
181
|
#--
|
|
147
|
-
#: (name: Symbol, type:
|
|
182
|
+
#: (name: Symbol, type: Symbol, required: bool, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?default: untyped, ?item_type: Symbol?, ?dimensions: Integer, ?nested_params: Riffer::Params?, ?variants: Array[Riffer::Params | Riffer::Params::Param]?) -> void
|
|
148
183
|
def initialize(name:, type:, required:, description: nil, enum: nil, format: nil, default: nil, item_type: nil,
|
|
149
184
|
dimensions: 1, nested_params: nil, variants: nil)
|
|
150
|
-
if type ==
|
|
151
|
-
raise Riffer::ArgumentError, "#{name}: an AnyOf param requires variants"
|
|
152
|
-
end
|
|
185
|
+
raise Riffer::ArgumentError, "#{name}: an :any_of param requires variants" if type == :any_of && variants.nil?
|
|
153
186
|
|
|
154
187
|
@name = name.to_sym
|
|
155
188
|
@type = type
|
|
@@ -173,26 +206,22 @@ class Riffer::Params::Param
|
|
|
173
206
|
def valid_type?(value)
|
|
174
207
|
return true if value.nil? && !required
|
|
175
208
|
|
|
176
|
-
if
|
|
177
|
-
[true, false].include?(value)
|
|
178
|
-
elsif type == Float
|
|
179
|
-
value.is_a?(Numeric)
|
|
180
|
-
elsif type == Riffer::Params::AnyOf
|
|
209
|
+
if type == :any_of
|
|
181
210
|
Array(variants).any? { |variant| variant.is_a?(Riffer::Params) ? value.is_a?(Hash) : variant.valid_type?(value) }
|
|
182
211
|
else
|
|
183
|
-
|
|
212
|
+
self.class.value_of_type?(type, value)
|
|
184
213
|
end
|
|
185
214
|
end
|
|
186
215
|
|
|
187
216
|
#--
|
|
188
217
|
#: () -> String
|
|
189
218
|
def type_name
|
|
190
|
-
if type ==
|
|
219
|
+
if type == :any_of
|
|
191
220
|
names = Array(variants).map { |variant| variant.is_a?(Riffer::Params) ? "object" : variant.type_name }
|
|
192
221
|
return names.uniq.join(" or ")
|
|
193
222
|
end
|
|
194
223
|
|
|
195
|
-
|
|
224
|
+
type.name
|
|
196
225
|
end
|
|
197
226
|
|
|
198
227
|
#--
|
|
@@ -202,7 +231,7 @@ class Riffer::Params::Param
|
|
|
202
231
|
# Nullable so strict providers can distinguish absent from present.
|
|
203
232
|
nullable = strict && !required
|
|
204
233
|
|
|
205
|
-
if type ==
|
|
234
|
+
if type == :any_of && variants
|
|
206
235
|
schema = { anyOf: variants.map { |variant| variant.to_json_schema(strict: strict) } } #: Hash[Symbol, untyped]
|
|
207
236
|
schema[:anyOf] << { type: "null" } if nullable
|
|
208
237
|
schema[:description] = description if description
|
|
@@ -233,13 +262,13 @@ class Riffer::Params::Param
|
|
|
233
262
|
# source for +from_json_schema+.
|
|
234
263
|
schema[:default] = default unless strict || default.nil?
|
|
235
264
|
|
|
236
|
-
if self.type ==
|
|
265
|
+
if self.type == :array && nested_params
|
|
237
266
|
schema[:items] = nested_params.to_json_schema(strict: strict)
|
|
238
|
-
elsif self.type ==
|
|
239
|
-
items = { type:
|
|
267
|
+
elsif self.type == :array && item_type
|
|
268
|
+
items = { type: item_type.name, enum: enum, format: format }.compact #: Hash[Symbol, untyped]
|
|
240
269
|
(dimensions - 1).times { items = { type: "array", items: items } }
|
|
241
270
|
schema[:items] = items
|
|
242
|
-
elsif self.type ==
|
|
271
|
+
elsif self.type == :object && nested_params
|
|
243
272
|
# The nested schema carries its own type: "object", which would clobber a nullable union.
|
|
244
273
|
schema.merge!(nested_params.to_json_schema(strict: strict).except(:type))
|
|
245
274
|
end
|
|
@@ -262,16 +291,16 @@ class Riffer::Params::Param
|
|
|
262
291
|
@default = Riffer::Helpers::DeepDup.call(source.default)
|
|
263
292
|
end
|
|
264
293
|
|
|
265
|
-
# The first matching variant wins, and a
|
|
294
|
+
# The first matching variant wins, and a :number variant without an enum accepts any number.
|
|
266
295
|
#--
|
|
267
296
|
#: () -> void
|
|
268
297
|
def validate_variant_order!
|
|
269
298
|
primitives = Array(variants).grep(Riffer::Params::Param) #: Array[Riffer::Params::Param]
|
|
270
|
-
|
|
271
|
-
integer = primitives.rindex { |variant| variant.type ==
|
|
272
|
-
return unless
|
|
299
|
+
number = primitives.index { |variant| variant.type == :number && variant.enum.nil? }
|
|
300
|
+
integer = primitives.rindex { |variant| variant.type == :integer }
|
|
301
|
+
return unless number && integer && number < integer
|
|
273
302
|
|
|
274
|
-
raise Riffer::ArgumentError, "#{name}: an
|
|
303
|
+
raise Riffer::ArgumentError, "#{name}: an :integer variant after a :number variant without enum: can never match"
|
|
275
304
|
end
|
|
276
305
|
|
|
277
306
|
#--
|
|
@@ -282,8 +311,8 @@ class Riffer::Params::Param
|
|
|
282
311
|
"#{name}: format: must be a supported format (#{Riffer::Params::Format::NAMES.join(', ')}), " \
|
|
283
312
|
"got #{format.inspect}"
|
|
284
313
|
end
|
|
285
|
-
unless type ==
|
|
286
|
-
raise Riffer::ArgumentError, "#{name}: format: requires
|
|
314
|
+
unless type == :string || (type == :array && item_type == :string)
|
|
315
|
+
raise Riffer::ArgumentError, "#{name}: format: requires :string or an :array whose innermost type is :string"
|
|
287
316
|
end
|
|
288
317
|
raise Riffer::ArgumentError, "#{name}: format: cannot be used with enum:" if enum
|
|
289
318
|
end
|
|
@@ -292,12 +321,12 @@ class Riffer::Params::Param
|
|
|
292
321
|
#: () -> void
|
|
293
322
|
def validate_strict_shape!
|
|
294
323
|
# Strict providers reject objects without properties and arrays without items.
|
|
295
|
-
if type ==
|
|
324
|
+
if type == :object && nested_params.nil?
|
|
296
325
|
raise Riffer::ArgumentError,
|
|
297
|
-
"#{name}:
|
|
298
|
-
elsif type ==
|
|
326
|
+
"#{name}: an :object param requires a block defining its properties under strict schemas"
|
|
327
|
+
elsif type == :array && nested_params.nil? && item_type.nil?
|
|
299
328
|
raise Riffer::ArgumentError,
|
|
300
|
-
"#{name}: an
|
|
329
|
+
"#{name}: an :array param requires a block or of: defining its items under strict schemas"
|
|
301
330
|
end
|
|
302
331
|
end
|
|
303
332
|
end
|
data/lib/riffer/params.rb
CHANGED
|
@@ -29,46 +29,18 @@ class Riffer::Params
|
|
|
29
29
|
end
|
|
30
30
|
|
|
31
31
|
#--
|
|
32
|
-
#: (Symbol, singleton(Riffer::Params::AnyOf), ?description: String?) { (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> void
|
|
33
|
-
#: (Symbol, Module, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?of: (Module | Array[untyped])?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
|
|
32
|
+
#: (Symbol, :any_of | singleton(Riffer::Params::AnyOf), ?description: String?) { (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> void
|
|
33
|
+
#: (Symbol, Symbol | Module, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?of: (Symbol | Module | Array[untyped])?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
|
|
34
34
|
def required(name, type, description: nil, enum: nil, format: nil, of: nil, &)
|
|
35
|
-
|
|
36
|
-
nested = build_nested(type, item_type, enum, &) unless type == Riffer::Params::AnyOf
|
|
37
|
-
variants = build_variants(name, of, enum, &) if type == Riffer::Params::AnyOf
|
|
38
|
-
@parameters << Riffer::Params::Param.new(
|
|
39
|
-
name: name,
|
|
40
|
-
type: type,
|
|
41
|
-
required: true,
|
|
42
|
-
description: description,
|
|
43
|
-
enum: enum,
|
|
44
|
-
format: format,
|
|
45
|
-
item_type: item_type,
|
|
46
|
-
dimensions: dimensions,
|
|
47
|
-
nested_params: nested,
|
|
48
|
-
variants: variants,
|
|
49
|
-
)
|
|
35
|
+
add_param(name, type, required: true, description: description, enum: enum, format: format, of: of, &)
|
|
50
36
|
end
|
|
51
37
|
|
|
52
38
|
#--
|
|
53
|
-
#: (Symbol, singleton(Riffer::Params::AnyOf), ?description: String?, ?default: untyped) { (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> void
|
|
54
|
-
#: (Symbol, Module, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?default: untyped, ?of: (Module | Array[untyped])?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
|
|
39
|
+
#: (Symbol, :any_of | singleton(Riffer::Params::AnyOf), ?description: String?, ?default: untyped) { (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> void
|
|
40
|
+
#: (Symbol, Symbol | Module, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?default: untyped, ?of: (Symbol | Module | Array[untyped])?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
|
|
55
41
|
def optional(name, type, description: nil, enum: nil, format: nil, default: nil, of: nil, &)
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
variants = build_variants(name, of, enum, &) if type == Riffer::Params::AnyOf
|
|
59
|
-
@parameters << Riffer::Params::Param.new(
|
|
60
|
-
name: name,
|
|
61
|
-
type: type,
|
|
62
|
-
required: false,
|
|
63
|
-
description: description,
|
|
64
|
-
enum: enum,
|
|
65
|
-
format: format,
|
|
66
|
-
default: default,
|
|
67
|
-
item_type: item_type,
|
|
68
|
-
dimensions: dimensions,
|
|
69
|
-
nested_params: nested,
|
|
70
|
-
variants: variants,
|
|
71
|
-
)
|
|
42
|
+
add_param(name, type,
|
|
43
|
+
required: false, description: description, enum: enum, format: format, default: default, of: of, &)
|
|
72
44
|
end
|
|
73
45
|
|
|
74
46
|
#--
|
|
@@ -138,7 +110,30 @@ class Riffer::Params
|
|
|
138
110
|
end
|
|
139
111
|
|
|
140
112
|
#--
|
|
141
|
-
#: ((Module | Array[untyped])
|
|
113
|
+
#: (Symbol, untyped, required: bool, description: String?, enum: Array[untyped]?, format: String?, ?default: untyped, of: (Symbol | Module | Array[untyped])?) ?{ (untyped) [self: untyped] -> void } -> void
|
|
114
|
+
def add_param(name, type, required:, description:, enum:, format:, of:, default: nil, &)
|
|
115
|
+
type = Riffer::Params::Param.resolve_type!(type, "type", Riffer::Params::Param::TYPES)
|
|
116
|
+
of_type, dimensions = unwrap_of(of)
|
|
117
|
+
item_type = Riffer::Params::Param.resolve_type!(of_type, "of:", Riffer::Params::Param::PRIMITIVE_TYPES) if of_type
|
|
118
|
+
nested = build_nested(type, item_type, enum, &) unless type == :any_of
|
|
119
|
+
variants = build_variants(name, of, enum, &) if type == :any_of
|
|
120
|
+
@parameters << Riffer::Params::Param.new(
|
|
121
|
+
name: name,
|
|
122
|
+
type: type,
|
|
123
|
+
required: required,
|
|
124
|
+
description: description,
|
|
125
|
+
enum: enum,
|
|
126
|
+
format: format,
|
|
127
|
+
default: default,
|
|
128
|
+
item_type: item_type,
|
|
129
|
+
dimensions: dimensions,
|
|
130
|
+
nested_params: nested,
|
|
131
|
+
variants: variants,
|
|
132
|
+
)
|
|
133
|
+
end
|
|
134
|
+
|
|
135
|
+
#--
|
|
136
|
+
#: ((Symbol | Module | Array[untyped])?, ?Integer) -> [(Symbol | Module)?, Integer]
|
|
142
137
|
def unwrap_of(of, dimensions = 1)
|
|
143
138
|
return [of, dimensions] unless of.is_a?(Array)
|
|
144
139
|
raise Riffer::ArgumentError, "of: must nest exactly one type, got #{of.inspect}" unless of.size == 1 && of.first
|
|
@@ -147,25 +142,21 @@ class Riffer::Params
|
|
|
147
142
|
end
|
|
148
143
|
|
|
149
144
|
#--
|
|
150
|
-
#: (
|
|
145
|
+
#: (Symbol, Symbol?, Array[untyped]?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?
|
|
151
146
|
def build_nested(type, of, enum, &block)
|
|
152
147
|
raise Riffer::ArgumentError, "cannot use both of: and a block" if of && block
|
|
153
|
-
raise Riffer::ArgumentError, "enum: cannot be used with
|
|
154
|
-
raise Riffer::ArgumentError, "enum: with
|
|
148
|
+
raise Riffer::ArgumentError, "enum: cannot be used with :object" if enum && type == :object
|
|
149
|
+
raise Riffer::ArgumentError, "enum: with :array requires of:" if enum && type == :array && !of
|
|
155
150
|
|
|
156
151
|
if of
|
|
157
|
-
raise Riffer::ArgumentError, "of: can only be used with
|
|
152
|
+
raise Riffer::ArgumentError, "of: can only be used with :array, got #{type.inspect}" unless type == :array
|
|
158
153
|
|
|
159
|
-
unless Riffer::Params::Param::PRIMITIVE_TYPES.include?(of)
|
|
160
|
-
primitives = Riffer::Params::Param::PRIMITIVE_TYPES.map(&:name).join(", ")
|
|
161
|
-
raise Riffer::ArgumentError, "of: must be a primitive type (#{primitives}), got #{of}"
|
|
162
|
-
end
|
|
163
154
|
return nil
|
|
164
155
|
end
|
|
165
156
|
|
|
166
157
|
return unless block
|
|
167
|
-
unless [
|
|
168
|
-
raise Riffer::ArgumentError, "block can only be used with
|
|
158
|
+
unless %i[object array].include?(type)
|
|
159
|
+
raise Riffer::ArgumentError, "block can only be used with :object or :array, got #{type.inspect}"
|
|
169
160
|
end
|
|
170
161
|
|
|
171
162
|
nested = Riffer::Params.new
|
|
@@ -174,15 +165,15 @@ class Riffer::Params
|
|
|
174
165
|
end
|
|
175
166
|
|
|
176
167
|
#--
|
|
177
|
-
#: (Symbol, (Module | Array[untyped])?, Array[untyped]?) ?{ (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> Array[Riffer::Params | Riffer::Params::Param]
|
|
168
|
+
#: (Symbol, (Symbol | Module | Array[untyped])?, Array[untyped]?) ?{ (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> Array[Riffer::Params | Riffer::Params::Param]
|
|
178
169
|
def build_variants(name, of, enum, &block)
|
|
179
|
-
raise Riffer::ArgumentError, "of: cannot be used with
|
|
180
|
-
raise Riffer::ArgumentError, "enum: cannot be used with
|
|
181
|
-
raise Riffer::ArgumentError, "
|
|
170
|
+
raise Riffer::ArgumentError, "of: cannot be used with :any_of" if of
|
|
171
|
+
raise Riffer::ArgumentError, "enum: cannot be used with :any_of" if enum
|
|
172
|
+
raise Riffer::ArgumentError, ":any_of requires a block defining its variants" unless block
|
|
182
173
|
|
|
183
174
|
any_of = Riffer::Params::AnyOf.new(name)
|
|
184
175
|
any_of.instance_eval(&block)
|
|
185
|
-
raise Riffer::ArgumentError, "
|
|
176
|
+
raise Riffer::ArgumentError, ":any_of requires at least two variants" if any_of.variants.size < 2
|
|
186
177
|
|
|
187
178
|
any_of.variants
|
|
188
179
|
end
|
|
@@ -203,13 +194,13 @@ class Riffer::Params
|
|
|
203
194
|
#--
|
|
204
195
|
#: (Riffer::Params::Param, untyped, Array[String]) -> untyped
|
|
205
196
|
def validate_nested(param, value, errors)
|
|
206
|
-
if param.type ==
|
|
197
|
+
if param.type == :any_of
|
|
207
198
|
validate_any_of(param, value, errors)
|
|
208
|
-
elsif param.type ==
|
|
199
|
+
elsif param.type == :object && param.nested_params
|
|
209
200
|
validate_nested_hash(param, value, errors)
|
|
210
|
-
elsif param.type ==
|
|
201
|
+
elsif param.type == :array && param.nested_params
|
|
211
202
|
validate_nested_array_of_objects(param, value, errors)
|
|
212
|
-
elsif param.type ==
|
|
203
|
+
elsif param.type == :array && param.item_type
|
|
213
204
|
validate_typed_array(param, value, errors)
|
|
214
205
|
else
|
|
215
206
|
value
|
|
@@ -322,8 +313,8 @@ class Riffer::Params
|
|
|
322
313
|
next item
|
|
323
314
|
end
|
|
324
315
|
|
|
325
|
-
unless
|
|
326
|
-
errors << "#{item_path} must be a #{
|
|
316
|
+
unless Riffer::Params::Param.value_of_type?(item_type, item)
|
|
317
|
+
errors << "#{item_path} must be a #{item_type.name}"
|
|
327
318
|
next item
|
|
328
319
|
end
|
|
329
320
|
|
|
@@ -342,23 +333,11 @@ class Riffer::Params
|
|
|
342
333
|
end
|
|
343
334
|
|
|
344
335
|
#--
|
|
345
|
-
#: (
|
|
346
|
-
def valid_item?(type, item)
|
|
347
|
-
if [Riffer::Params::Boolean, TrueClass, FalseClass].include?(type)
|
|
348
|
-
[true, false].include?(item)
|
|
349
|
-
elsif type == Float
|
|
350
|
-
item.is_a?(Numeric)
|
|
351
|
-
else
|
|
352
|
-
item.is_a?(type)
|
|
353
|
-
end
|
|
354
|
-
end
|
|
355
|
-
|
|
356
|
-
#--
|
|
357
|
-
#: (Module, untyped) -> untyped
|
|
336
|
+
#: (Symbol, untyped) -> untyped
|
|
358
337
|
def coerce_value(type, value)
|
|
359
338
|
# JSON Schema "number" accepts integers; callers shouldn't get a type that
|
|
360
339
|
# depends on whether the model wrote a decimal point.
|
|
361
|
-
return value.to_f if type ==
|
|
340
|
+
return value.to_f if type == :number
|
|
362
341
|
|
|
363
342
|
value
|
|
364
343
|
end
|
|
@@ -68,12 +68,13 @@ class Riffer::Providers::AnthropicCompatible::MessagesAPI::Stream
|
|
|
68
68
|
when "content_block_delta" then apply_delta(event, yielder)
|
|
69
69
|
when "content_block_stop" then stop_block(event, yielder)
|
|
70
70
|
when "message_delta" then apply_message_delta(event)
|
|
71
|
-
when "message_stop" then
|
|
71
|
+
when "message_stop" then @completed = true
|
|
72
72
|
when "error" then raise_stream_error(event)
|
|
73
73
|
end
|
|
74
74
|
end
|
|
75
75
|
|
|
76
|
-
# The caller reads finish reason and usage from here
|
|
76
|
+
# The caller reads the text, finish reason and usage from here, since one turn
|
|
77
|
+
# can take several streams.
|
|
77
78
|
#--
|
|
78
79
|
#: () -> Hash[Symbol, untyped]
|
|
79
80
|
def finish!
|
|
@@ -180,14 +181,6 @@ class Riffer::Providers::AnthropicCompatible::MessagesAPI::Stream
|
|
|
180
181
|
@message[:usage] = (@message[:usage] || {}).merge(usage.compact) if usage
|
|
181
182
|
end
|
|
182
183
|
|
|
183
|
-
#--
|
|
184
|
-
#: (Riffer::Providers::_EventSink) -> void
|
|
185
|
-
def stop_message(yielder)
|
|
186
|
-
@completed = true
|
|
187
|
-
text = @message[:content].filter_map { |block| block[:text] if block[:type] == "text" }.join
|
|
188
|
-
yielder << Riffer::StreamEvents::TextDone.new(text) unless text.empty?
|
|
189
|
-
end
|
|
190
|
-
|
|
191
184
|
#--
|
|
192
185
|
#: (Hash[Symbol, untyped]) -> void
|
|
193
186
|
def raise_stream_error(event)
|