llm.rb 4.9.0 → 4.11.0

data/lib/llm/providers/google/response_adapter/completion.rb

@@ -51,6 +51,12 @@ module LLM::Google::ResponseAdapter
       super
     end
 
+    ##
+    # (see LLM::Contract::Completion#reasoning_content)
+    def reasoning_content
+      super
+    end
+
     ##
     # (see LLM::Contract::Completion#content!)
     def content!
@@ -60,21 +66,22 @@ module LLM::Google::ResponseAdapter
     private
 
     def adapt_choices
-      candidates.map.with_index do |choice, index|
+      candidates.map.with_index do |choice, cindex|
         content = choice.content || LLM::Object.new
         role = content.role || "model"
         parts = content.parts || [{"text" => choice.finishReason}]
         text = parts.filter_map { _1["text"] }.join
         tools = parts.select { _1["functionCall"] }
-        extra = {index:, response: self, tool_calls: adapt_tool_calls(tools), original_tool_calls: tools}
+        extra = {index: cindex, response: self, tool_calls: adapt_tool_calls(parts, cindex), original_tool_calls: tools}
         LLM::Message.new(role, text, extra)
       end
     end
 
-    def adapt_tool_calls(parts)
-      (parts || []).map do |part|
+    def adapt_tool_calls(parts, cindex)
+      (parts || []).each_with_index.filter_map do |part, pindex|
         tool = part["functionCall"]
-        {name: tool.name, arguments: tool.args}
+        next unless tool
+        {id: LLM::Google.tool_id(part:, cindex:, pindex:), name: tool.name, arguments: tool.args}
       end
     end
 

data/lib/llm/providers/google/stream_parser.rb

@@ -10,11 +10,13 @@ class LLM::Google
     attr_reader :body
 
     ##
-    # @param [#<<] io An IO-like object
+    # @param [#<<, LLM::Stream] stream
+    #  A stream sink that implements {#<<} or the {LLM::Stream} interface
     # @return [LLM::Google::StreamParser]
-    def initialize(io)
+    def initialize(stream)
       @body = {"candidates" => []}
-      @io = io
+      @stream = stream
+      @emits = {tools: []}
     end
 
     ##
@@ -24,6 +26,13 @@ class LLM::Google
       tap { merge_chunk!(chunk) }
     end
 
+    ##
+    # Frees internal parser state used during streaming.
+    # @return [void]
+    def free
+      @emits.clear
+    end
+
     private
 
     def merge_chunk!(chunk)
@@ -49,7 +58,7 @@ class LLM::Google
         delta.each do |key, value|
           k = key.to_s
           if k == "content"
-            merge_candidate_content!(candidate["content"], value) if value
+            merge_candidate_content!(candidate["content"], value, index) if value
           else
             candidate[k] = value # Overwrite other fields
           end
@@ -57,24 +66,24 @@ class LLM::Google
       end
     end
 
-    def merge_candidate_content!(content, delta)
+    def merge_candidate_content!(content, delta, cindex)
       delta.each do |key, value|
         k = key.to_s
         if k == "parts"
           content["parts"] ||= []
-          merge_content_parts!(content["parts"], value) if value
+          merge_content_parts!(content["parts"], value, cindex) if value
         else
           content[k] = value
         end
       end
     end
 
-    def merge_content_parts!(parts, deltas)
+    def merge_content_parts!(parts, deltas, cindex)
       deltas.each do |delta|
         if delta["text"]
           merge_text!(parts, delta)
         elsif delta["functionCall"]
-          merge_function_call!(parts, delta)
+          merge_function_call!(parts, delta, cindex)
         elsif delta["inlineData"]
           parts << delta
         elsif delta["functionResponse"]
@@ -93,14 +102,14 @@ class LLM::Google
       if last_existing_part.is_a?(Hash) && last_existing_part["text"]
         last_existing_part["text"] ||= +""
         last_existing_part["text"] << text
-        @io << text if @io.respond_to?(:<<)
+        emit_content(text)
       else
         parts << delta
-        @io << text if @io.respond_to?(:<<)
+        emit_content(text)
       end
     end
 
-    def merge_function_call!(parts, delta)
+    def merge_function_call!(parts, delta, cindex)
       last_existing_part = parts.last
       last_call = last_existing_part.is_a?(Hash) ? last_existing_part["functionCall"] : nil
       delta_call = delta["functionCall"]
@@ -113,6 +122,40 @@ class LLM::Google
       else
         parts << delta
       end
+      emit_tool(parts.length - 1, cindex, parts.last || delta)
+    end
+
+    def emit_content(value)
+      if @stream.respond_to?(:on_content)
+        @stream.on_content(value)
+      elsif @stream.respond_to?(:<<)
+        @stream << value
+      end
+    end
+
+    def emit_tool(pindex, cindex, part)
+      return unless @stream.respond_to?(:on_tool_call)
+      return unless complete_tool?(part)
+      key = [cindex, pindex]
+      return if @emits[:tools].include?(key)
+      function, error = resolve_tool(part, cindex, pindex)
+      @emits[:tools] << key
+      @stream.on_tool_call(function, error)
+    end
+
+    def complete_tool?(part)
+      call = part["functionCall"]
+      call && call["name"] && Hash === call["args"]
+    end
+
+    def resolve_tool(part, cindex, pindex)
+      call = part["functionCall"]
+      registered = LLM::Function.find_by_name(call["name"])
+      fn = (registered || LLM::Function.new(call["name"])).dup.tap do |fn|
+        fn.id = LLM::Google.tool_id(part:, cindex:, pindex:)
+        fn.arguments = call["args"]
+      end
+      [fn, (registered ? nil : @stream.tool_not_found(fn))]
     end
   end
 end

data/lib/llm/providers/google/utils.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class LLM::Google
+  module Utils
+    ##
+    # Returns a stable internal tool-call ID for Gemini function calls.
+    #
+    # Gemini responses may omit a direct tool-call ID, but llm.rb expects one
+    # for matching pending tool calls with tool returns across streaming and
+    # normal completion flows.
+    #
+    # When Gemini provides a `thoughtSignature`, that value is used as the
+    # basis for the ID. Otherwise the ID falls back to the candidate and part
+    # indexes, which are stable within the response.
+    #
+    # @param part [Hash]
+    #   A Gemini content part containing a `functionCall`.
+    # @param cindex [Integer]
+    #   The candidate index for the tool call.
+    # @param pindex [Integer]
+    #   The part index for the tool call within the candidate.
+    # @return [String]
+    #   Returns a stable internal tool-call ID.
+    def tool_id(part:, cindex:, pindex:)
+      signature = part["thoughtSignature"].to_s
+      return "google_#{signature}" unless signature.empty?
+      "google_call_#{cindex}_#{pindex}"
+    end
+  end
+end

data/lib/llm/providers/google.rb

@@ -18,6 +18,7 @@ module LLM
   #   ctx.talk ["Tell me about this photo", ctx.local_file("/images/photo.png")]
   #   ctx.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
   class Google < Provider
+    require_relative "google/utils"
     require_relative "google/error_handler"
     require_relative "google/request_adapter"
     require_relative "google/response_adapter"
@@ -28,6 +29,7 @@ module LLM
     require_relative "google/files"
 
     include RequestAdapter
+    extend Utils
 
     HOST = "generativelanguage.googleapis.com"
 

data/lib/llm/providers/ollama/response_adapter/completion.rb

@@ -51,6 +51,12 @@ module LLM::Ollama::ResponseAdapter
       super
     end
 
+    ##
+    # (see LLM::Contract::Completion#reasoning_content)
+    def reasoning_content
+      super
+    end
+
     ##
     # (see LLM::Contract::Completion#content!)
     def content!

data/lib/llm/providers/ollama/stream_parser.rb

@@ -11,9 +11,9 @@ class LLM::Ollama
 
     ##
     # @return [LLM::OpenAI::Chunk]
-    def initialize(io)
+    def initialize(stream)
       @body = {}
-      @io = io
+      @stream = stream
     end
 
     ##
@@ -23,6 +23,12 @@ class LLM::Ollama
       tap { merge!(chunk) }
     end
 
+    ##
+    # Frees internal parser state used during streaming.
+    # @return [void]
+    def free
+    end
+
     private
 
     def merge!(chunk)
@@ -30,10 +36,10 @@ class LLM::Ollama
         if key == "message"
           if @body[key]
             @body[key]["content"] << value["content"]
-            @io << value["content"] if @io.respond_to?(:<<)
+            @stream << value["content"] if @stream.respond_to?(:<<)
           else
             @body[key] = value
-            @io << value["content"] if @io.respond_to?(:<<)
+            @stream << value["content"] if @stream.respond_to?(:<<)
           end
         else
           @body[key] = value

data/lib/llm/providers/ollama.rb

@@ -122,7 +122,7 @@ module LLM
       tools  = resolve_tools(params.delete(:tools))
       params = [params, {format: params[:schema]}, adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), params.delete(:stream)
-      params[:stream] = true if stream.respond_to?(:<<) || stream == true
+      params[:stream] = true if streamable?(stream) || stream == true
       [params, stream, tools, role]
     end
 

data/lib/llm/providers/openai/response_adapter/completion.rb

@@ -10,6 +10,7 @@ module LLM::OpenAI::ResponseAdapter
         extra = {
           index:, response: self,
           logprobs: choice.logprobs,
+          reasoning_content: message.reasoning_content,
           tool_calls: adapt_tool_calls(message.tool_calls),
           original_tool_calls: message.tool_calls
         }
@@ -63,6 +64,12 @@ module LLM::OpenAI::ResponseAdapter
       super
     end
 
+    ##
+    # (see LLM::Contract::Completion#reasoning_content)
+    def reasoning_content
+      super
+    end
+
     ##
     # (see LLM::Contract::Completion#content!)
     def content!

data/lib/llm/providers/openai/response_adapter/responds.rb

@@ -2,29 +2,101 @@
 
 module LLM::OpenAI::ResponseAdapter
   module Responds
-    def model = body.model
-    def response_id = respond_to?(:response) ? response["id"] : id
-    def choices = [adapt_message]
-    def annotations = choices[0].annotations
+    ##
+    # (see LLM::Contract::Completion#messages)
+    def messages
+      [adapt_message]
+    end
+    alias_method :choices, :messages
+
+    ##
+    # @return [String]
+    def response_id
+      respond_to?(:response) ? response["id"] : id
+    end
+
+    ##
+    # @return [Array<Hash>]
+    def annotations = messages[0].annotations
+
+    ##
+    # (see LLM::Contract::Completion#input_tokens)
+    def input_tokens
+      body.usage&.input_tokens || 0
+    end
+    alias_method :prompt_tokens, :input_tokens
+
+    ##
+    # (see LLM::Contract::Completion#output_tokens)
+    def output_tokens
+      body.usage&.output_tokens || 0
+    end
+    alias_method :completion_tokens, :output_tokens
+
+    ##
+    # (see LLM::Contract::Completion#reasoning_tokens)
+    def reasoning_tokens
+      body
+        .usage
+        &.output_tokens_details
+        &.reasoning_tokens || 0
+    end
+
+    ##
+    # (see LLM::Contract::Completion#total_tokens)
+    def total_tokens
+      body.usage&.total_tokens || 0
+    end
 
-    def prompt_tokens = body.usage&.input_tokens
-    def completion_tokens = body.usage&.output_tokens
-    def total_tokens = body.usage&.total_tokens
+    ##
+    # (see LLM::Contract::Completion#usage)
+    def usage
+      super
+    end
+
+    ##
+    # (see LLM::Contract::Completion#model)
+    def model
+      body.model
+    end
 
     ##
     # Returns the aggregated text content from the response outputs.
     # @return [String]
     def output_text
-      choices.find(&:assistant?).content || ""
+      content
+    end
+
+    ##
+    # (see LLM::Contract::Completion#content)
+    def content
+      super || ""
+    end
+
+    ##
+    # (see LLM::Contract::Completion#content!)
+    def content!
+      super
+    end
+
+    ##
+    # (see LLM::Contract::Completion#reasoning_content)
+    def reasoning_content
+      super
     end
 
     private
 
     def adapt_message
-      message = LLM::Message.new("assistant", +"", {response: self, tool_calls: []})
-      output.each.with_index do |choice, index|
+      message = LLM::Message.new("assistant", +"", {response: self, tool_calls: [], reasoning_content: +""})
+      output.each do |choice|
         if choice.type == "function_call"
           message.extra[:tool_calls] << adapt_tool(choice)
+        elsif choice.type == "reasoning"
+          (choice.summary || []).each do |summary|
+            next unless summary["type"] == "summary_text"
+            message.extra["reasoning_content"] << summary["text"]
+          end
         elsif choice.content
           choice.content.each do |c|
             next unless c["type"] == "output_text"
@@ -48,5 +120,7 @@ module LLM::OpenAI::ResponseAdapter
     rescue *LLM.json.parser_error
       {}
     end
+
+    include LLM::Contract::Completion
   end
 end

data/lib/llm/providers/openai/responses/stream_parser.rb

@@ -10,11 +10,13 @@ class LLM::OpenAI
     attr_reader :body
 
     ##
-    # @param [#<<] io An IO-like object
+    # @param [#<<, LLM::Stream] stream
+    #  A stream sink that implements {#<<} or the {LLM::Stream} interface
     # @return [LLM::OpenAI::Responses::StreamParser]
-    def initialize(io)
+    def initialize(stream)
       @body = {"output" => []}
-      @io = io
+      @stream = stream
+      @emits = {tools: []}
     end
 
     ##
@@ -24,6 +26,13 @@ class LLM::OpenAI
       tap { handle_event(chunk) }
     end
 
+    ##
+    # Frees internal parser state used during streaming.
+    # @return [void]
+    def free
+      @emits.clear
+    end
+
     private
 
     def handle_event(chunk)
@@ -56,9 +65,21 @@ class LLM::OpenAI
           if content_part && content_part["type"] == "output_text"
             content_part["text"] ||= ""
             content_part["text"] << delta_text
-            @io << delta_text if @io.respond_to?(:<<)
+            emit_content(delta_text)
           end
         end
+      when "response.function_call_arguments.delta"
+        output_item = @body["output"][chunk["output_index"]]
+        if output_item && output_item["type"] == "function_call"
+          output_item["arguments"] ||= +""
+          output_item["arguments"] << chunk["delta"]
+        end
+      when "response.function_call_arguments.done"
+        output_item = @body["output"][chunk["output_index"]]
+        if output_item && output_item["type"] == "function_call"
+          output_item["arguments"] = chunk["arguments"]
+          emit_tool(chunk["output_index"], output_item)
+        end
       when "response.output_item.done"
         output_index = chunk["output_index"]
         item = chunk["item"]
@@ -72,5 +93,43 @@ class LLM::OpenAI
         @body["output"][output_index]["content"][content_index] = part
       end
     end
+
+    def emit_content(value)
+      if @stream.respond_to?(:on_content)
+        @stream.on_content(value)
+      elsif @stream.respond_to?(:<<)
+        @stream << value
+      end
+    end
+
+    def emit_tool(index, tool)
+      return unless @stream.respond_to?(:on_tool_call)
+      return unless complete_tool?(tool)
+      return if @emits[:tools].include?(index)
+      function, error = resolve_tool(tool)
+      @emits[:tools] << index
+      @stream.on_tool_call(function, error)
+    end
+
+    def complete_tool?(tool)
+      tool["call_id"] && tool["name"] && parse_arguments(tool["arguments"])
+    end
+
+    def resolve_tool(tool)
+      registered = LLM::Function.find_by_name(tool["name"])
+      fn = (registered || LLM::Function.new(tool["name"])).dup.tap do |fn|
+        fn.id = tool["call_id"]
+        fn.arguments = parse_arguments(tool["arguments"])
+      end
+      [fn, (registered ? nil : @stream.tool_not_found(fn))]
+    end
+
+    def parse_arguments(arguments)
+      return nil if arguments.to_s.empty?
+      parsed = LLM.json.load(arguments)
+      Hash === parsed ? parsed : nil
+    rescue *LLM.json.parser_error
+      nil
+    end
   end
 end

data/lib/llm/providers/openai/responses.rb

@@ -39,7 +39,7 @@ class LLM::OpenAI
       tools  = resolve_tools(params.delete(:tools))
       params = [params, adapt_schema(params), adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), params.delete(:stream)
-      params[:stream] = true if stream.respond_to?(:<<) || stream == true
+      params[:stream] = true if @provider.streamable?(stream) || stream == true
       req = Net::HTTP::Post.new("/v1/responses", headers)
       messages = build_complete_messages(prompt, params, role)
       @provider.tracer.set_request_metadata(user_input: extract_user_input(messages, fallback: prompt))

data/lib/llm/providers/openai/stream_parser.rb

@@ -11,9 +11,10 @@ class LLM::OpenAI
 
     ##
     # @return [LLM::OpenAI::Chunk]
-    def initialize(io)
+    def initialize(stream)
       @body = {}
-      @io = io
+      @stream = stream
+      @emits = {tools: []}
     end
 
     ##
@@ -23,6 +24,13 @@ class LLM::OpenAI
       tap { merge!(chunk) }
     end
 
+    ##
+    # Frees internal parser state used during streaming.
+    # @return [void]
+    def free
+      @emits.clear
+    end
+
     private
 
     def merge!(chunk)
@@ -47,7 +55,11 @@ class LLM::OpenAI
             if key == "content"
               target_message[key] ||= +""
               target_message[key] << value
-              @io << value if @io.respond_to?(:<<)
+              emit_content(value)
+            elsif key == "reasoning_content"
+              target_message[key] ||= +""
+              target_message[key] << value
+              emit_reasoning_content(value)
             elsif key == "tool_calls"
               merge_tools!(target_message, value)
             else
@@ -60,8 +72,13 @@ class LLM::OpenAI
           (choice["delta"] || {}).each do |key, value|
             next if value.nil?
             if key == "content"
-              @io << value if @io.respond_to?(:<<)
+              emit_content(value)
+              message_hash[key] = value
+            elsif key == "reasoning_content"
+              emit_reasoning_content(value)
               message_hash[key] = value
+            elsif key == "tool_calls"
+              merge_tools!(message_hash, value)
             else
               message_hash[key] = value
             end
@@ -85,7 +102,54 @@ class LLM::OpenAI
         else
           target["tool_calls"][tindex] = toola
         end
+        emit_tool(target["tool_calls"][tindex], tindex)
+      end
+    end
+
+    def emit_content(value)
+      if @stream.respond_to?(:on_content)
+        @stream.on_content(value)
+      elsif @stream.respond_to?(:<<)
+        @stream << value
+      end
+    end
+
+    def emit_reasoning_content(value)
+      if @stream.respond_to?(:on_reasoning_content)
+        @stream.on_reasoning_content(value)
       end
     end
+
+    def emit_tool(tool, tindex)
+      return unless @stream.respond_to?(:on_tool_call)
+      return unless complete_tool?(tool)
+      return if @emits[:tools].include?(tindex)
+      function, error = resolve_tool(tool)
+      @emits[:tools] << tindex
+      @stream.on_tool_call(function, error)
+    end
+
+    def complete_tool?(tool)
+      function = tool["function"]
+      function && tool["id"] && function["name"] && parse_arguments(function["arguments"])
+    end
+
+    def resolve_tool(tool)
+      function = tool["function"]
+      registered = LLM::Function.find_by_name(function["name"])
+      fn = (registered || LLM::Function.new(function["name"])).dup.tap do |fn|
+        fn.id = tool["id"]
+        fn.arguments = parse_arguments(function["arguments"])
+      end
+      [fn, (registered ? nil : @stream.tool_not_found(fn))]
+    end
+
+    def parse_arguments(arguments)
+      return nil if arguments.to_s.empty?
+      parsed = LLM.json.load(arguments)
+      Hash === parsed ? parsed : nil
+    rescue *LLM.json.parser_error
+      nil
+    end
   end
 end

data/lib/llm/providers/openai.rb

@@ -212,7 +212,7 @@ module LLM
       tools = resolve_tools(params.delete(:tools))
       params = [params, adapt_schema(params), adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), params.delete(:stream)
-      params[:stream] = true if stream.respond_to?(:<<) || stream == true
+      params[:stream] = true if streamable?(stream) || stream == true
       if params[:stream]
         params[:stream_options] = {include_usage: true}.merge!(params[:stream_options] || {})
       end

data/lib/llm/schema/all_of.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class LLM::Schema
+  ##
+  # The {LLM::Schema::AllOf LLM::Schema::AllOf} class represents an
+  # allOf union in a JSON schema. It is a subclass of
+  # {LLM::Schema::Leaf LLM::Schema::Leaf}.
+  class AllOf < Leaf
+    ##
+    # Returns an allOf union for the given types.
+    # @return [LLM::Schema::AllOf]
+    def self.[](*types)
+      schema = LLM::Schema.new
+      new(types.map { LLM::Schema::Utils.resolve(schema, _1) })
+    end
+
+    ##
+    # @param [Array<LLM::Schema::Leaf>] values
+    #  The values required by the union
+    # @return [LLM::Schema::AllOf]
+    def initialize(values)
+      @values = values
+    end
+
+    ##
+    # @return [Hash]
+    def to_h
+      super.merge!(allOf: @values)
+    end
+  end
+end