riffer 0.56.0 → 0.57.1

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.
Files changed (90) hide show
  1. checksums.yaml +4 -4
  2. data/.release-please-manifest.json +1 -1
  3. data/CHANGELOG.md +26 -0
  4. data/README.md +1 -1
  5. data/docs/AGENTS.md +105 -50
  6. data/docs/AGENT_LIFECYCLE.md +1 -1
  7. data/docs/CONFIGURATION.md +7 -3
  8. data/docs/EVALS.md +2 -0
  9. data/docs/MCP.md +36 -0
  10. data/docs/MESSAGES.md +13 -0
  11. data/docs/OVERVIEW.md +7 -7
  12. data/docs/SERIALIZATION.md +12 -2
  13. data/docs/SKILLS.md +1 -1
  14. data/docs/STABILITY.md +1 -1
  15. data/docs/TOOLS.md +93 -37
  16. data/docs/TOOL_ADVANCED.md +7 -0
  17. data/docs/providers/AMAZON_BEDROCK.md +6 -2
  18. data/docs/providers/ANTHROPIC.md +35 -2
  19. data/docs/providers/AZURE_OPENAI.md +9 -3
  20. data/docs/providers/CUSTOM_PROVIDERS.md +19 -0
  21. data/docs/providers/GEMINI.md +8 -4
  22. data/docs/providers/GOOGLE_CLOUD.md +10 -5
  23. data/docs/providers/MOCK_PROVIDER.md +2 -0
  24. data/docs/providers/OPENAI.md +25 -3
  25. data/docs/providers/OPENROUTER.md +11 -3
  26. data/docs/providers/PROVIDERS.md +1 -1
  27. data/docs-site/index.html.erb +1 -1
  28. data/lib/riffer/agent/config.rb +21 -0
  29. data/lib/riffer/agent/context.rb +36 -18
  30. data/lib/riffer/agent/run.rb +54 -8
  31. data/lib/riffer/agent/serializer.rb +5 -0
  32. data/lib/riffer/agent/session.rb +1 -0
  33. data/lib/riffer/agent.rb +43 -0
  34. data/lib/riffer/config/mcp.rb +17 -0
  35. data/lib/riffer/config/pricing.rb +2 -2
  36. data/lib/riffer/config.rb +12 -1
  37. data/lib/riffer/evals/evaluator.rb +8 -1
  38. data/lib/riffer/evals/evaluator_runner.rb +1 -0
  39. data/lib/riffer/evals/judge.rb +2 -2
  40. data/lib/riffer/evals.rb +2 -0
  41. data/lib/riffer/mcp/search_tool.rb +1 -1
  42. data/lib/riffer/mcp.rb +7 -0
  43. data/lib/riffer/messages/tool.rb +6 -2
  44. data/lib/riffer/params/any_of.rb +5 -8
  45. data/lib/riffer/params/boolean.rb +1 -1
  46. data/lib/riffer/params/param.rb +96 -67
  47. data/lib/riffer/params.rb +50 -71
  48. data/lib/riffer/providers/anthropic_compatible/messages_api/stream.rb +3 -10
  49. data/lib/riffer/providers/anthropic_compatible/messages_api.rb +89 -13
  50. data/lib/riffer/providers/anthropic_vertex.rb +7 -0
  51. data/lib/riffer/providers/base.rb +43 -7
  52. data/lib/riffer/providers/deferred_tool_gateway/sink.rb +54 -0
  53. data/lib/riffer/providers/deferred_tool_gateway/tool.rb +17 -0
  54. data/lib/riffer/providers/deferred_tool_gateway.rb +150 -0
  55. data/lib/riffer/providers/gemini.rb +5 -5
  56. data/lib/riffer/providers/mock.rb +6 -0
  57. data/lib/riffer/providers/open_ai.rb +38 -10
  58. data/lib/riffer/skills/activate_tool.rb +1 -1
  59. data/lib/riffer/tool.rb +92 -2
  60. data/lib/riffer/tools/response.rb +11 -2
  61. data/lib/riffer/version.rb +1 -1
  62. data/sig/generated/riffer/agent/config.rbs +13 -1
  63. data/sig/generated/riffer/agent/context.rbs +16 -0
  64. data/sig/generated/riffer/agent/run.rbs +14 -2
  65. data/sig/generated/riffer/agent.rbs +13 -0
  66. data/sig/generated/riffer/config/mcp.rbs +7 -0
  67. data/sig/generated/riffer/config.rbs +5 -1
  68. data/sig/generated/riffer/evals/evaluator.rbs +4 -0
  69. data/sig/generated/riffer/evals.rbs +1 -0
  70. data/sig/generated/riffer/mcp.rbs +1 -0
  71. data/sig/generated/riffer/messages/tool.rbs +4 -2
  72. data/sig/generated/riffer/params/any_of.rbs +4 -4
  73. data/sig/generated/riffer/params/boolean.rbs +1 -1
  74. data/sig/generated/riffer/params/param.rbs +28 -14
  75. data/sig/generated/riffer/params.rbs +20 -20
  76. data/sig/generated/riffer/providers/anthropic_compatible/messages_api/stream.rbs +2 -5
  77. data/sig/generated/riffer/providers/anthropic_compatible/messages_api.rbs +34 -2
  78. data/sig/generated/riffer/providers/anthropic_vertex.rbs +5 -0
  79. data/sig/generated/riffer/providers/base.rbs +13 -0
  80. data/sig/generated/riffer/providers/deferred_tool_gateway/sink.rbs +23 -0
  81. data/sig/generated/riffer/providers/deferred_tool_gateway/tool.rbs +4 -0
  82. data/sig/generated/riffer/providers/deferred_tool_gateway.rbs +58 -0
  83. data/sig/generated/riffer/providers/mock.rbs +4 -0
  84. data/sig/generated/riffer/providers/open_ai.rbs +16 -4
  85. data/sig/generated/riffer/tool.rbs +48 -2
  86. data/sig/generated/riffer/tools/response.rbs +9 -2
  87. data/sig/manual/riffer/providers/deferred_tool_gateway.rbs +5 -0
  88. metadata +8 -3
  89. data/lib/riffer/tools/toolable.rb +0 -113
  90. data/sig/generated/riffer/tools/toolable.rbs +0 -66
@@ -4,31 +4,27 @@
4
4
  require "json"
5
5
 
6
6
  class Riffer::Params::Param
7
- TYPE_MAPPINGS = {
8
- String => "string",
9
- Integer => "integer",
10
- Float => "number",
11
- Riffer::Params::Boolean => "boolean",
12
- TrueClass => "boolean",
13
- FalseClass => "boolean",
14
- Array => "array",
15
- Hash => "object",
16
- }.freeze #: Hash[Module, String]
17
-
18
- PRIMITIVE_TYPES = (TYPE_MAPPINGS.keys - [Array, Hash]).freeze #: Array[Module]
19
-
20
- JSON_TYPE_MAPPINGS = {
21
- "string" => String,
22
- "integer" => Integer,
23
- "number" => Float,
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 #: Module # @dynamic 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 #: Module? # @dynamic 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
- ruby_type = variants ? Riffer::Params::AnyOf : json_type_to_ruby(schema[:type])
56
- nested = resolve_nested_params(ruby_type, schema)
57
- item_type, dimensions, items = resolve_typed_items(schema) if ruby_type == Array && !nested
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: ruby_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
- #: (Module, Hash[Symbol, untyped]) -> Riffer::Params?
95
- def self.resolve_nested_params(ruby_type, schema)
96
- if ruby_type == Hash && schema[:properties]
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 ruby_type == Array && schema[:items].is_a?(Hash) && schema[:items][:properties]
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]) -> [Module, Integer, 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 json_type_to_ruby(items[:type]) == Array
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 = json_type_to_ruby(items[: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) -> Module
139
- def self.json_type_to_ruby(type)
173
+ #: (untyped) -> Symbol
174
+ def self.json_type(type)
140
175
  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}")
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 :json_type_to_ruby
179
+ private_class_method :json_type
145
180
 
146
181
  #--
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
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 == Riffer::Params::AnyOf && variants.nil?
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 [Riffer::Params::Boolean, TrueClass, FalseClass].include?(type)
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
- value.is_a?(type)
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 == Riffer::Params::AnyOf
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
- TYPE_MAPPINGS[type] || type.to_s.downcase
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 == Riffer::Params::AnyOf && variants
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 == Array && nested_params
265
+ if self.type == :array && nested_params
237
266
  schema[:items] = nested_params.to_json_schema(strict: strict)
238
- elsif self.type == Array && item_type
239
- items = { type: TYPE_MAPPINGS[item_type], enum: enum, format: format }.compact #: Hash[Symbol, untyped]
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 == Hash && nested_params
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 Float variant without an enum accepts any number.
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
- 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
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 Integer variant after a Float variant without enum: can never match"
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 == String || (type == Array && item_type == String)
286
- raise Riffer::ArgumentError, "#{name}: format: requires a String or an Array whose innermost type is String"
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 == Hash && nested_params.nil?
324
+ if type == :object && nested_params.nil?
296
325
  raise Riffer::ArgumentError,
297
- "#{name}: a Hash param requires a block defining its properties under strict schemas"
298
- elsif type == Array && nested_params.nil? && item_type.nil?
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 Array param requires a block or of: defining its items under strict schemas"
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
- item_type, dimensions = unwrap_of(of)
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
- item_type, dimensions = unwrap_of(of)
57
- nested = build_nested(type, item_type, enum, &) unless type == Riffer::Params::AnyOf
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])?, ?Integer) -> [Module?, Integer]
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
- #: (Module, Module?, Array[untyped]?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?
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 Hash" if enum && type == Hash
154
- raise Riffer::ArgumentError, "enum: with Array requires of:" if enum && type == Array && !of
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 Array type, got #{type}" unless type == Array
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 [Hash, Array].include?(type)
168
- raise Riffer::ArgumentError, "block can only be used with Hash or Array type, got #{type}"
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 AnyOf" if of
180
- raise Riffer::ArgumentError, "enum: cannot be used with AnyOf" if enum
181
- raise Riffer::ArgumentError, "AnyOf requires a block defining its variants" unless block
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, "AnyOf requires at least two variants" if any_of.variants.size < 2
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 == Riffer::Params::AnyOf
197
+ if param.type == :any_of
207
198
  validate_any_of(param, value, errors)
208
- elsif param.type == Hash && param.nested_params
199
+ elsif param.type == :object && param.nested_params
209
200
  validate_nested_hash(param, value, errors)
210
- elsif param.type == Array && param.nested_params
201
+ elsif param.type == :array && param.nested_params
211
202
  validate_nested_array_of_objects(param, value, errors)
212
- elsif param.type == Array && param.item_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 valid_item?(item_type, item)
326
- errors << "#{item_path} must be a #{Riffer::Params::Param::TYPE_MAPPINGS[item_type]}"
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
- #: (Module, untyped) -> bool
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 == Float
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 stop_message(yielder)
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 so it can price the usage.
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)