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.
Files changed (117) hide show
  1. checksums.yaml +4 -4
  2. data/.claude/rules/rbs-inline.md +6 -6
  3. data/.release-please-manifest.json +1 -1
  4. data/.ruby-version +1 -1
  5. data/CHANGELOG.md +46 -0
  6. data/README.md +26 -1
  7. data/Steepfile +2 -2
  8. data/UPGRADING.md +3 -0
  9. data/docs/AGENTS.md +37 -12
  10. data/docs/AGENT_LIFECYCLE.md +1 -1
  11. data/docs/CATALOG.md +8 -8
  12. data/docs/CONFIGURATION.md +95 -17
  13. data/docs/GUARDRAILS.md +2 -0
  14. data/docs/MCP.md +3 -4
  15. data/docs/MESSAGES.md +112 -15
  16. data/docs/STABILITY.md +32 -0
  17. data/docs/STREAM_EVENTS.md +17 -1
  18. data/docs/TESTING.md +22 -1
  19. data/docs/TOOLS.md +11 -11
  20. data/docs/TRACING.md +1 -1
  21. data/docs/providers/AMAZON_BEDROCK.md +3 -1
  22. data/docs/providers/ANTHROPIC.md +44 -44
  23. data/docs/providers/CUSTOM_PROVIDERS.md +59 -0
  24. data/docs/providers/GEMINI.md +76 -26
  25. data/docs/providers/GOOGLE_CLOUD.md +363 -0
  26. data/docs/providers/MOCK_PROVIDER.md +2 -0
  27. data/docs/providers/OPENAI.md +3 -1
  28. data/docs/providers/PROVIDERS.md +30 -18
  29. data/docs-site/manifest.yml +6 -0
  30. data/lib/riffer/agent/run.rb +28 -13
  31. data/lib/riffer/agent/session.rb +33 -10
  32. data/lib/riffer/agent/structured_output.rb +6 -1
  33. data/lib/riffer/config/anthropic.rb +9 -0
  34. data/lib/riffer/config/future.rb +53 -0
  35. data/lib/riffer/config/gemini.rb +9 -0
  36. data/lib/riffer/config/google_cloud.rb +38 -0
  37. data/lib/riffer/config/pricing.rb +5 -15
  38. data/lib/riffer/config.rb +19 -0
  39. data/lib/riffer/deprecation/event.rb +25 -0
  40. data/lib/riffer/deprecation.rb +60 -0
  41. data/lib/riffer/http/client.rb +141 -0
  42. data/lib/riffer/http.rb +5 -0
  43. data/lib/riffer/mcp/client.rb +0 -1
  44. data/lib/riffer/messages/assistant/server_tool_part.rb +73 -0
  45. data/lib/riffer/messages/assistant/text_part.rb +52 -0
  46. data/lib/riffer/messages/assistant.rb +64 -17
  47. data/lib/riffer/params/any_of.rb +37 -9
  48. data/lib/riffer/params/param.rb +35 -14
  49. data/lib/riffer/params.rb +34 -19
  50. data/lib/riffer/providers/amazon_bedrock.rb +38 -5
  51. data/lib/riffer/providers/anthropic/client.rb +49 -0
  52. data/lib/riffer/providers/anthropic.rb +19 -452
  53. data/lib/riffer/providers/anthropic_compatible/messages_api/stream.rb +219 -0
  54. data/lib/riffer/providers/anthropic_compatible/messages_api.rb +315 -0
  55. data/lib/riffer/providers/anthropic_compatible.rb +5 -0
  56. data/lib/riffer/providers/anthropic_vertex.rb +66 -0
  57. data/lib/riffer/providers/base.rb +19 -13
  58. data/lib/riffer/providers/gemini/client.rb +17 -85
  59. data/lib/riffer/providers/gemini.rb +213 -81
  60. data/lib/riffer/providers/google_cloud/client.rb +106 -0
  61. data/lib/riffer/providers/google_cloud.rb +99 -0
  62. data/lib/riffer/providers/open_ai.rb +21 -16
  63. data/lib/riffer/providers/repository.rb +2 -0
  64. data/lib/riffer/stream_events/server_tool_done.rb +21 -0
  65. data/lib/riffer/testing.rb +6 -0
  66. data/lib/riffer/version.rb +1 -1
  67. data/lib/riffer/wire/sse.rb +51 -0
  68. data/lib/riffer/wire.rb +31 -0
  69. data/lib/riffer.rb +20 -0
  70. data/rbs_collection.lock.yaml +24 -4
  71. data/sig/_private/faraday.rbs +8 -0
  72. data/sig/_private/googleauth.rbs +7 -0
  73. data/sig/generated/riffer/agent/run.rbs +5 -0
  74. data/sig/generated/riffer/agent/session.rbs +6 -0
  75. data/sig/generated/riffer/config/anthropic.rbs +6 -0
  76. data/sig/generated/riffer/config/future.rbs +29 -0
  77. data/sig/generated/riffer/config/gemini.rbs +6 -0
  78. data/sig/generated/riffer/config/google_cloud.rbs +28 -0
  79. data/sig/generated/riffer/config/pricing.rbs +0 -9
  80. data/sig/generated/riffer/config.rbs +10 -0
  81. data/sig/generated/riffer/deprecation/event.rbs +17 -0
  82. data/sig/generated/riffer/deprecation.rbs +27 -0
  83. data/sig/generated/riffer/http/client.rbs +59 -0
  84. data/sig/generated/riffer/http.rbs +4 -0
  85. data/sig/generated/riffer/messages/assistant/server_tool_part.rbs +44 -0
  86. data/sig/generated/riffer/messages/assistant/text_part.rbs +35 -0
  87. data/sig/generated/riffer/messages/assistant.rbs +24 -11
  88. data/sig/generated/riffer/params/any_of.rbs +13 -5
  89. data/sig/generated/riffer/params/param.rbs +10 -5
  90. data/sig/generated/riffer/params.rbs +8 -4
  91. data/sig/generated/riffer/providers/amazon_bedrock.rbs +14 -2
  92. data/sig/generated/riffer/providers/anthropic/client.rbs +34 -0
  93. data/sig/generated/riffer/providers/anthropic.rbs +5 -124
  94. data/sig/generated/riffer/providers/anthropic_compatible/messages_api/stream.rbs +81 -0
  95. data/sig/generated/riffer/providers/anthropic_compatible/messages_api.rbs +108 -0
  96. data/sig/generated/riffer/providers/anthropic_compatible.rbs +4 -0
  97. data/sig/generated/riffer/providers/anthropic_vertex.rbs +45 -0
  98. data/sig/generated/riffer/providers/base.rbs +5 -0
  99. data/sig/generated/riffer/providers/gemini/client.rbs +11 -34
  100. data/sig/generated/riffer/providers/gemini.rbs +66 -4
  101. data/sig/generated/riffer/providers/google_cloud/client.rbs +71 -0
  102. data/sig/generated/riffer/providers/google_cloud.rbs +64 -0
  103. data/sig/generated/riffer/providers/open_ai.rbs +7 -2
  104. data/sig/generated/riffer/stream_events/server_tool_done.rbs +15 -0
  105. data/sig/generated/riffer/testing.rbs +4 -0
  106. data/sig/generated/riffer/wire/sse.rbs +23 -0
  107. data/sig/generated/riffer/wire.rbs +17 -0
  108. data/sig/generated/riffer.rbs +15 -0
  109. data/sig/manual/riffer/deprecation.rbs +5 -0
  110. data/sig/manual/riffer/providers/anthropic_compatible/messages_api.rbs +8 -0
  111. data/sig/manual/riffer/providers/gemini.rbs +8 -0
  112. data/sig/manual/riffer/providers/google_cloud.rbs +8 -0
  113. data/sig/manual/riffer/wire.rbs +5 -0
  114. metadata +76 -5
  115. data/sig/_private/anthropic.rbs +0 -17
  116. data/sig/_private/riffer/providers/anthropic.rbs +0 -6
  117. 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
- super(content, id: id)
64
- @tool_calls = tool_calls
65
- @reasoning = reasoning
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, content: content } #: Hash[Symbol, untyped]
147
+ hash = { role: role } #: Hash[Symbol, untyped]
117
148
  hash[:id] = id if id
118
- hash[:tool_calls] = tool_calls.map(&:to_h) unless tool_calls.empty?
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
@@ -2,21 +2,49 @@
2
2
  # rbs_inline: enabled
3
3
 
4
4
  class Riffer::Params::AnyOf
5
- attr_reader :variants #: Array[Riffer::Params] # @dynamic variants
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
- raise Riffer::ArgumentError, "variant requires a block defining its properties" unless block
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
- params = Riffer::Params.new
19
- params.instance_eval(&block)
20
- @variants << params
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
@@ -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
- raise Riffer::ArgumentError, "Unsupported anyOf branch: #{branch.to_json}" unless branch[:type] == "object"
80
-
81
- Riffer::Params.from_json_schema(branch)
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 object branches" if variants.size < 2
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
- key = type.is_a?(Array) ? type.find { |t| t != "null" } : type
137
- JSON_TYPE_MAPPINGS.fetch(key) { raise Riffer::ArgumentError, "Unsupported JSON Schema type: #{type.inspect}" }
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 it too.
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
- return "object" if type == Riffer::Params::AnyOf
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
- unless param.valid_type?(value)
94
- errors << "#{param.name} must be a #{param.type_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, Hash[Symbol, untyped], Array[String]) -> Hash[Symbol, untyped]
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
- arguments: tool_call[:arguments],
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