ruby_llm 2.2.0 → 2.2.1

data/lib/ruby_llm/models.rb

@@ -281,7 +281,30 @@ module RubyLLM
                            .flatten
 
         provider_models = provider_fetch[:models] + preserved_models
-        merge_models(provider_models, models_dev_fetch[:models])
+        models_dev_models = models_dev_fetch[:models]
+        if models_dev_fetch[:fetched]
+          models_dev_models += models_dev_gaps(existing_models, provider_fetch[:models], models_dev_models)
+        end
+        merge_models(provider_models, models_dev_models)
+      end
+
+      # models.dev sometimes drops a model its provider still serves. Until it
+      # lists the model again, keep the pricing, modalities and limits it last
+      # gave, and say so, so the gap gets reported upstream.
+      def models_dev_gaps(existing_models, listed_models, models_dev_models) # :nodoc:
+        models_dev_by_key = index_by_key(models_dev_models)
+        listed_by_key = index_by_key(listed_models)
+
+        existing_models.select do |model|
+          next false unless model.metadata[:source] == 'models.dev'
+
+          key = "#{model.provider}:#{model.id}"
+          listed = listed_by_key[key]
+          next false if listed.nil? || find_models_dev_model(key, models_dev_by_key, listed)
+
+          RubyLLM.logger.warn("kept from the previous registry: #{key} (missing from models.dev)")
+          true
+        end
       end
 
       def merge_models(provider_models, models_dev_models) # :nodoc:

data/lib/ruby_llm/protocols/gemini/batches.rb

@@ -106,15 +106,84 @@ module RubyLLM
                                response_schema(value)
                              end
           end
-          nullable_type(schema)
+          numeric_enum(type_union(schema))
         end
 
-        def nullable_type(schema)
+        TYPE_KEYWORDS = {
+          'string' => %w[format maxLength minLength pattern],
+          'number' => %w[format maximum minimum exclusiveMaximum exclusiveMinimum multipleOf],
+          'integer' => %w[format maximum minimum exclusiveMaximum exclusiveMinimum multipleOf],
+          'object' => %w[properties required maxProperties minProperties propertyOrdering],
+          'array' => %w[items maxItems minItems prefixItems uniqueItems]
+        }.freeze
+        TYPED_KEYWORDS = TYPE_KEYWORDS.values.flatten.uniq.freeze
+        ENUM_VALUE_TYPES = {
+          'string' => ->(value) { value.is_a?(String) },
+          'number' => ->(value) { value.is_a?(Numeric) },
+          'integer' => ->(value) { value.is_a?(Integer) },
+          'boolean' => ->(value) { [true, false].include?(value) },
+          'object' => ->(value) { value.is_a?(Hash) },
+          'array' => ->(value) { value.is_a?(Array) },
+          'null' => lambda(&:nil?)
+        }.freeze
+        private_constant :TYPE_KEYWORDS, :TYPED_KEYWORDS, :ENUM_VALUE_TYPES
+
+        # Gemini's Schema takes one type, so a JSON Schema type array becomes
+        # nullable plus anyOf, each member keeping the keywords and enum
+        # values of its type.
+        def type_union(schema)
           key = schema.key?(:type) ? :type : 'type'
-          types = Array(schema[key])
-          return schema unless types.length > 1 && types.include?('null')
+          return schema unless schema[key].is_a?(Array)
 
-          schema.merge(key => (types - ['null']).first, nullable: true)
+          types = schema[key].map(&:to_s).uniq
+          return schema.merge(key => types.first) if types.one?
+
+          types = enum_types(schema, types)
+          others = types - ['null']
+          return schema.merge(key => 'null') if others.empty?
+
+          union = type_union_members(schema.except(key), others)
+          types.include?('null') ? union.merge(nullable: true) : union
+        end
+
+        def type_union_members(schema, types)
+          return union_member(schema, types.first) if types.one?
+
+          { anyOf: types.map { |type| union_member(schema, type) } }
+        end
+
+        def union_member(schema, type)
+          own = TYPE_KEYWORDS.fetch(type, [])
+          member = schema.reject { |name, _| TYPED_KEYWORDS.include?(name.to_s) && !own.include?(name.to_s) }
+          values = member[enum_key(member)]
+          member = member.merge(enum_key(member) => values.select(&enum_value_of(type))) if values.is_a?(Array)
+          numeric_enum({ type: }.merge(member))
+        end
+
+        # Gemini's Schema.enum is a list of strings; it constrains an integer
+        # or number schema to those values written as strings.
+        def numeric_enum(schema)
+          type = schema[:type] || schema['type']
+          values = schema[enum_key(schema)]
+          return schema unless %w[integer number].include?(type.to_s) && values.is_a?(Array)
+
+          schema.merge(enum_key(schema) => values.map { |value| value.is_a?(Numeric) ? value.to_s : value })
+        end
+
+        def enum_types(schema, types)
+          values = schema[enum_key(schema)]
+          return types unless values.is_a?(Array)
+
+          matching = types.select { |type| values.any?(&enum_value_of(type)) }
+          matching.empty? ? types : matching
+        end
+
+        def enum_key(schema)
+          schema.key?(:enum) ? :enum : 'enum'
+        end
+
+        def enum_value_of(type)
+          ENUM_VALUE_TYPES.fetch(type) { ->(_) { true } }
         end
 
         def batch_name(id)

data/lib/ruby_llm/protocols/openai/decisions.rb

@@ -27,12 +27,14 @@ module RubyLLM
 
         def parse_judgment_response(response, questions:)
           body = response.body
+          tokens = parse_tokens(body['usage'])
+          # The provider billed this attempt even if its answers don't parse.
+          @usage_tracker&.observe_tokens(tokens)
           named = body.fetch('answers').to_h { |answer| [answer.fetch('name'), answer] }
           answers = questions.values.to_h do |question|
             [question.name, parse_answer(named.fetch(question.name.to_s), question)]
           end
-          RubyLLM::Judgment.new(answers:, model: body.fetch('model'), raw: response, model_info: @model,
-                                tokens: parse_tokens(body['usage']))
+          RubyLLM::Judgment.new(answers:, model: body.fetch('model'), raw: response, model_info: @model, tokens:)
         rescue KeyError, NoMethodError, TypeError => e
           raise Error.new('OpenAI Decisions returned an invalid judgment', provider_message: e.message, response:,
                                                                            redact: @config&.redact_error_messages)

data/lib/ruby_llm/protocols/system_one/responses.rb

@@ -9,14 +9,14 @@ module RubyLLM
         def parse_judgment_response(response, questions:)
           body = response.body
           usage = body['usage'] || {}
+          tokens = Tokens.new(input: usage['input_tokens'], output: usage['output_tokens'],
+                              reported_cost: reported_cost(usage))
+          # The provider billed this attempt even if its answers don't parse.
+          @usage_tracker&.observe_tokens(tokens)
           answers = questions.values.to_h do |question|
             [question.name, parse_answer(body.fetch('answers').fetch(question.name.to_s), question)]
           end
-          RubyLLM::Judgment.new(
-            answers:, model: body['model'], raw: response, model_info: @model,
-            tokens: Tokens.new(input: usage['input_tokens'], output: usage['output_tokens'],
-                               reported_cost: reported_cost(usage))
-          )
+          RubyLLM::Judgment.new(answers:, model: body['model'], raw: response, model_info: @model, tokens:)
         rescue KeyError, NoMethodError, TypeError => e
           raise Error.new('System One returned an invalid judgment', provider_message: e.message, response:,
                                                                      redact: @config&.redact_error_messages)

data/lib/ruby_llm/version.rb

@@ -2,5 +2,5 @@
 
 module RubyLLM
   # The version of the ruby_llm gem, as a string.
-  VERSION = '2.2.0'
+  VERSION = '2.2.1'
 end

data/skills/rubyllm/references/tools-and-agents.md

@@ -2,7 +2,7 @@
 
 Read this when the task adds tools, agents, subagents, or per-request state.
 
-- Subclass `RubyLLM::Tool`. Use `description`, `parameter`, or a `parameters` block, and keyword arguments on `execute`. Register tools with `with_tools`; configure choice and concurrency with `with_tool_options`. For models that loop on tools, set `with_tool_options(rounds: 25)` (off by default, 2.2): after that many model responses asking for tools, `complete` raises `RubyLLM::ToolRoundLimitError` with every call answered, and calling `complete` again continues with a fresh count. Keep application authorization in the tool or underlying service. Use `requires_approval` when the product needs a user's decision before execution, and `ask` inside `execute` when the tool needs the user's answer to go on: the call runs again from the top with the answer, so ask first, then act (2.2). Call `halt(result)` in a tool that says the last word, so the turn ends without another model call (2.2). Declare `exclusive` on tools that share state, such as a browser page, so they run alone in a concurrent round (2.2). With large tool sets, pass `defer: true` to `with_tools` or `with_mcp` (or declare `defer` on the class) so the model searches for tools instead of receiving them all (2.1).
+- Subclass `RubyLLM::Tool`. Use `description`, `parameter`, or a `parameters` block, and keyword arguments on `execute`. Register tools with `with_tools`; configure choice and concurrency with `with_tool_options`. For models that loop on tools, set `with_tool_options(rounds: 25)` (off by default, 2.2): after that many model responses asking for tools, `complete` raises `RubyLLM::ToolRoundLimitError` with every call answered, and calling `complete` again continues with a fresh count. To stop one response from making hundreds of calls, add `calls: 50` (2.2.1): the calls past it get an error result telling the model to go step by step, without running or asking for approval. Keep application authorization in the tool or underlying service. Use `requires_approval` when the product needs a user's decision before execution, and `ask` inside `execute` when the tool needs the user's answer to go on: the call runs again from the top with the answer, so ask first, then act (2.2). Call `halt(result)` in a tool that says the last word, so the turn ends without another model call (2.2). Declare `exclusive` on tools that share state, such as a browser page, so they run alone in a concurrent round (2.2). With large tool sets, pass `defer: true` to `with_tools` or `with_mcp` (or declare `defer` on the class) so the model searches for tools instead of receiving them all (2.1).
 - To hand work to another agent, put the agent class in `tools` (or `ResearchAgent.to_tool(customer:)` to fix its inputs): the model gives it a task, and a fresh agent answers within the call (2.2). That subagent can't wait, so it raises `RubyLLM::ConfigurationError` if it stops for an approval, a question, or a task. For a subagent that waits for a person in Rails, write a tool whose `execute` creates the subagent's chat with `BillingAgent.create!` and asks it, returns `RubyLLM::Task.new(status: :input_required, data: { "chat_id" => chat.id })` while that chat is `waiting?`, and whose `resume` finds it with `BillingAgent.find` and calls `complete`. The person answers the subagent chat's `pending_questions`; see `agents/#subagents-that-wait-for-a-person`.
 - When tools need a tenant, `Current` attributes, or other per-request state, set it with `around_tool_call` (or the agent macro), which runs in the tool's own thread or fiber (2.2), rather than passing the chat into every tool.
 - To turn a tool's exceptions into results the model reads, declare `rescue_from` on a base tool class, on `RubyLLM::Tool` for every tool, on `RubyLLM::CodeExecution`, or on an MCP server's class, rather than prepending a module around `call` (2.2). Subclasses use handlers declared later on their parents. The handler's return value becomes the call's result; re-raise to stop the chat. Handlers cover the calls a chat makes. Calling a tool directly (`tool.call(**args)` or `execute`) is still supported and isn't wrapped by handlers, so its exceptions reach the caller. A question from `ask` and a cancellation never reach it.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Carmine Paolino
@@ -884,7 +884,7 @@ metadata:
   funding_uri: https://github.com/sponsors/crmne
   rubygems_mfa_required: 'true'
 post_install_message: |
-  RubyLLM 2.2.0
+  RubyLLM 2.2.1
 
     Upgrading? Read the upgrade guide before you boot: