13: Refactor completion parameters

Author: tpaulshippy

lib/ruby_llm/chat.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'completion_params'
+
 module RubyLLM
   # Represents a conversation with an AI model. Handles message history,
   # streaming responses, and tool integration with a simple, conversational API.
@@ -100,15 +102,15 @@ def cache_prompts(system: false, user: false, tools: false)
 
     def complete(&)
       @on[:new_message]&.call
-      response = @provider.complete(
-        messages,
+      params = CompletionParams.new(
+        messages: messages,
         tools: @tools,
         temperature: @temperature,
         model: @model.id,
         cache_prompts: @cache_prompts.dup,
-        connection: @connection,
-        &
+        connection: @connection
       )
+      response = @provider.complete(params, &)
       @on[:end_message]&.call(response)
 
       add_message response

lib/ruby_llm/completion_params.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Parameter object for LLM completion requests.
+  # Encapsulates all the parameters needed for chat completion to avoid
+  # long parameter lists and provide better maintainability.
+  class CompletionParams
+    attr_reader :messages, :tools, :temperature, :model, :connection, :cache_prompts, :stream
+
+    def initialize(options = {})
+      @messages = options[:messages]
+      @tools = options[:tools]
+      @temperature = options[:temperature]
+      @model = options[:model]
+      @connection = options[:connection]
+      @cache_prompts = options[:cache_prompts] || { system: false, user: false, tools: false }
+      @stream = options[:stream] || false
+    end
+
+    def streaming?
+      @stream
+    end
+  end
+end

lib/ruby_llm/provider.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'completion_params'
+
 module RubyLLM
   # Base interface for LLM providers like OpenAI and Anthropic.
   # Handles the complexities of API communication, streaming responses,
@@ -10,21 +12,25 @@ module Provider
     module Methods
       extend Streaming
 
-      def complete(messages, tools:, temperature:, model:, connection:,
-                   cache_prompts: { system: false, user: false, tools: false }, &)
-        normalized_temperature = maybe_normalize_temperature(temperature, model)
+      def complete(params, &)
+        normalized_temperature = maybe_normalize_temperature(params.temperature, params.model)
+
+        completion_params = CompletionParams.new(
+          messages: params.messages,
+          tools: params.tools,
+          temperature: normalized_temperature,
+          model: params.model,
+          connection: params.connection,
+          cache_prompts: params.cache_prompts,
+          stream: block_given?
+        )
 
-        payload = render_payload(messages,
-                                 tools: tools,
-                                 temperature: normalized_temperature,
-                                 model: model,
-                                 cache_prompts: cache_prompts,
-                                 stream: block_given?)
+        payload = render_payload(completion_params)
 
         if block_given?
-          stream_response connection, payload, &
+          stream_response(completion_params.connection, payload, &)
         else
-          sync_response connection, payload
+          sync_response completion_params.connection, payload
         end
       end
 

lib/ruby_llm/providers/anthropic/chat.rb

@@ -11,14 +11,14 @@ def completion_url
           '/v1/messages'
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false,
-                           cache_prompts: { system: false, user: false, tools: false })
-          system_messages, chat_messages = separate_messages(messages)
-          system_content = build_system_content(system_messages, cache: cache_prompts[:system])
-
-          build_base_payload(chat_messages, temperature, model, stream, cache: cache_prompts[:user]).tap do |payload|
-            add_optional_fields(payload, system_content: system_content, tools: tools,
-                                         cache_tools: cache_prompts[:tools])
+        def render_payload(params)
+          system_messages, chat_messages = separate_messages(params.messages)
+          system_content = build_system_content(system_messages, cache: params.cache_prompts[:system])
+
+          build_base_payload(chat_messages, params.temperature, params.model, params.stream,
+                             cache: params.cache_prompts[:user]).tap do |payload|
+            add_optional_fields(payload, system_content: system_content, tools: params.tools,
+                                         cache_tools: params.cache_prompts[:tools])
           end
         end
 

lib/ruby_llm/providers/bedrock/chat.rb

@@ -39,20 +39,20 @@ def completion_url
           "model/#{@model_id}/invoke"
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, # rubocop:disable Lint/UnusedMethodArgument
-                           cache_prompts: { system: false, user: false, tools: false })
+        def render_payload(params)
           # Hold model_id in instance variable for use in completion_url and stream_url
-          @model_id = model
+          @model_id = params.model
 
-          system_messages, chat_messages = Anthropic::Chat.separate_messages(messages)
-          system_content = Anthropic::Chat.build_system_content(system_messages, cache: cache_prompts[:system])
+          system_messages, chat_messages = Anthropic::Chat.separate_messages(params.messages)
+          system_content = Anthropic::Chat.build_system_content(system_messages, cache: params.cache_prompts[:system])
 
-          build_base_payload(chat_messages, temperature, model, cache: cache_prompts[:user]).tap do |payload|
+          build_base_payload(chat_messages, params.temperature, params.model,
+                             cache: params.cache_prompts[:user]).tap do |payload|
             Anthropic::Chat.add_optional_fields(
               payload,
               system_content: system_content,
-              tools: tools,
-              cache_tools: cache_prompts[:tools]
+              tools: params.tools,
+              cache_tools: params.cache_prompts[:tools]
             )
           end
         end

lib/ruby_llm/providers/gemini/chat.rb

@@ -11,15 +11,15 @@ def completion_url
           "models/#{@model}:generateContent"
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, cache_prompts: {}) # rubocop:disable Lint/UnusedMethodArgument
-          @model = model # Store model for completion_url/stream_url
+        def render_payload(params)
+          @model = params.model # Store model for completion_url/stream_url
           payload = {
-            contents: format_messages(messages),
+            contents: format_messages(params.messages),
             generationConfig: {
-              temperature: temperature
+              temperature: params.temperature
             }
           }
-          payload[:tools] = format_tools(tools) if tools.any?
+          payload[:tools] = format_tools(params.tools) if params.tools.any?
           payload
         end
 

lib/ruby_llm/providers/openai/chat.rb

@@ -11,18 +11,18 @@ def completion_url
 
         module_function
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, cache_prompts: {}) # rubocop:disable Lint/UnusedMethodArgument
+        def render_payload(params)
           {
-            model: model,
-            messages: format_messages(messages),
-            temperature: temperature,
-            stream: stream
+            model: params.model,
+            messages: format_messages(params.messages),
+            temperature: params.temperature,
+            stream: params.stream
           }.tap do |payload|
-            if tools.any?
-              payload[:tools] = tools.map { |_, tool| tool_for(tool) }
+            if params.tools.any?
+              payload[:tools] = params.tools.map { |_, tool| tool_for(tool) }
               payload[:tool_choice] = 'auto'
             end
-            payload[:stream_options] = { include_usage: true } if stream
+            payload[:stream_options] = { include_usage: true } if params.stream
           end
         end