ruby_llm-agents 0.3.1 → 0.3.4

data/lib/ruby_llm/agents/base/response_building.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class Base
+      # Result object construction from LLM responses
+      #
+      # Handles building Result objects with full execution metadata
+      # including tokens, costs, timing, and tool calls.
+      module ResponseBuilding
+        # Builds a Result object from processed content and response metadata
+        #
+        # @param content [Hash, String] The processed response content
+        # @param response [RubyLLM::Message] The raw LLM response
+        # @return [Result] A Result object with full execution metadata
+        def build_result(content, response)
+          completed_at = Time.current
+          input_tokens = result_response_value(response, :input_tokens)
+          output_tokens = result_response_value(response, :output_tokens)
+          response_model_id = result_response_value(response, :model_id)
+
+          Result.new(
+            content: content,
+            input_tokens: input_tokens,
+            output_tokens: output_tokens,
+            cached_tokens: result_response_value(response, :cached_tokens, 0),
+            cache_creation_tokens: result_response_value(response, :cache_creation_tokens, 0),
+            model_id: model,
+            chosen_model_id: response_model_id || model,
+            temperature: temperature,
+            started_at: @execution_started_at,
+            completed_at: completed_at,
+            duration_ms: result_duration_ms(completed_at),
+            time_to_first_token_ms: @time_to_first_token_ms,
+            finish_reason: result_finish_reason(response),
+            streaming: self.class.streaming,
+            input_cost: result_input_cost(input_tokens, response_model_id),
+            output_cost: result_output_cost(output_tokens, response_model_id),
+            total_cost: result_total_cost(input_tokens, output_tokens, response_model_id),
+            tool_calls: @accumulated_tool_calls,
+            tool_calls_count: @accumulated_tool_calls.size
+          )
+        end
+
+        # Safely extracts a value from the response object
+        #
+        # @param response [Object] The response object
+        # @param method [Symbol] The method to call
+        # @param default [Object] Default value if method doesn't exist
+        # @return [Object] The extracted value or default
+        def result_response_value(response, method, default = nil)
+          return default unless response.respond_to?(method)
+          response.send(method) || default
+        end
+
+        # Calculates execution duration in milliseconds
+        #
+        # @param completed_at [Time] When execution completed
+        # @return [Integer, nil] Duration in ms or nil
+        def result_duration_ms(completed_at)
+          return nil unless @execution_started_at
+          ((completed_at - @execution_started_at) * 1000).to_i
+        end
+
+        # Extracts finish reason from response
+        #
+        # @param response [Object] The response object
+        # @return [String, nil] Normalized finish reason
+        def result_finish_reason(response)
+          reason = result_response_value(response, :finish_reason) ||
+                   result_response_value(response, :stop_reason)
+          return nil unless reason
+
+          # Normalize to standard values
+          case reason.to_s.downcase
+          when "stop", "end_turn" then "stop"
+          when "length", "max_tokens" then "length"
+          when "content_filter", "safety" then "content_filter"
+          when "tool_calls", "tool_use" then "tool_calls"
+          else "other"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/agents/base/tool_tracking.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class Base
+      # Tool call tracking for agent executions
+      #
+      # Handles accumulating and serializing tool calls made during
+      # an agent's execution cycle.
+      module ToolTracking
+        # Resets accumulated tool calls for a new execution
+        #
+        # @return [void]
+        def reset_accumulated_tool_calls!
+          @accumulated_tool_calls = []
+        end
+
+        # Extracts tool calls from all assistant messages in the conversation
+        #
+        # RubyLLM handles tool call loops internally. After ask() completes,
+        # the conversation history contains all intermediate assistant messages
+        # that had tool_calls. This method extracts those tool calls.
+        #
+        # @param client [RubyLLM::Chat] The chat client with conversation history
+        # @return [void]
+        def extract_tool_calls_from_client(client)
+          return unless client.respond_to?(:messages)
+
+          client.messages.each do |message|
+            next unless message.role == :assistant
+            next unless message.respond_to?(:tool_calls) && message.tool_calls.present?
+
+            message.tool_calls.each_value do |tool_call|
+              @accumulated_tool_calls << serialize_tool_call(tool_call)
+            end
+          end
+        end
+
+        # Serializes a single tool call to a hash
+        #
+        # @param tool_call [Object] The tool call object
+        # @return [Hash] Serialized tool call
+        def serialize_tool_call(tool_call)
+          if tool_call.respond_to?(:to_h)
+            tool_call.to_h.transform_keys(&:to_s)
+          else
+            {
+              "id" => tool_call.id,
+              "name" => tool_call.name,
+              "arguments" => tool_call.arguments
+            }
+          end
+        end
+      end
+    end
+  end
+end