activeagent 1.0.0.rc1 → 1.0.0

data/lib/active_agent/providers/ollama/chat/request.rb

@@ -1,66 +1,245 @@
 # frozen_string_literal: true
 
-require_relative "../../open_ai/chat/request"
-require_relative "requests/_types"
+require "delegate"
+require "json"
+require_relative "transforms"
 
 module ActiveAgent
   module Providers
     module Ollama
       module Chat
-        # Ollama uses the same request structure as OpenAI's chat completion API
-        # This class exists to allow for Ollama-specific customizations.
-        class Request < OpenAI::Chat::Request
-          # Messages array (required)
-          attribute :messages, Requests::Messages::MessagesType.new
+        # Wraps OpenAI gem's CompletionCreateParams with Ollama-specific extensions
+        #
+        # Delegates to OpenAI::Models::Chat::CompletionCreateParams for OpenAI-compatible
+        # parameters while adding support for Ollama-specific features like format,
+        # options, keep_alive, and raw mode.
+        #
+        # Ollama-specific parameters:
+        # - format: Return response in JSON or as a JSON schema (String "json" or Hash)
+        # - options: Additional model parameters (Hash of key-value pairs)
+        # - keep_alive: Controls how long model stays in memory (String duration or Integer seconds)
+        # - raw: If true, no formatting applied to prompt (Boolean)
+        #
+        # @example Basic usage
+        #   request = Request.new(
+        #     model: "llama2",
+        #     messages: [{role: "user", content: "Hello"}]
+        #   )
+        #
+        # @example With Ollama-specific features
+        #   request = Request.new(
+        #     model: "llama2",
+        #     messages: [{role: "user", content: "Hello"}],
+        #     format: "json",
+        #     options: {temperature: 0.7, num_predict: 100},
+        #     keep_alive: "5m"
+        #   )
+        class Request < SimpleDelegator
+          # Default parameter values
+          DEFAULTS = {
+            frequency_penalty: 0,
+            logprobs: false,
+            n: 1,
+            parallel_tool_calls: true,
+            presence_penalty: 0,
+            temperature: 1,
+            top_p: 1,
+            raw: false,
+            keep_alive: "5m"
+          }.freeze
 
-          # Ollama-specific parameters
+          # @return [Boolean, nil]
+          attr_reader :stream
 
-          # Format: return response in json or as a JSON schema
-          # Can be "json" or a JSON schema object
-          attribute :format
+          # @return [Hash] Ollama-specific parameters
+          attr_reader :ollama_params
 
-          # Options: additional model parameters (temperature, num_predict, etc.)
-          # Hash of key-value pairs for model-specific options
-          attribute :options
+          # Creates a new Ollama request
+          #
+          # @param params [Hash] request parameters
+          # @option params [String] :model model identifier (required)
+          # @option params [Array, String, Hash] :messages required conversation messages
+          # @option params [String, Hash] :format JSON format ("json" or schema object)
+          # @option params [Hash] :options model-specific options
+          # @option params [String, Integer] :keep_alive memory duration
+          # @option params [Boolean] :raw raw prompt mode
+          # @raise [ArgumentError] when parameters are invalid
+          def initialize(**params)
+            # Step 1: Extract stream flag
+            @stream = params[:stream]
 
-          # Keep alive: controls how long the model stays loaded in memory
-          # String duration (e.g., "5m", "1h") or integer in seconds
-          # Default: "5m"
-          attribute :keep_alive
+            # Step 2: Apply defaults
+            params = apply_defaults(params)
 
-          # Raw: if true, no formatting will be applied to the prompt
-          # You may use this if you are specifying a full templated prompt
-          attribute :raw, :boolean, default: false
+            # Step 3: Normalize parameters and split into OpenAI vs Ollama-specific
+            openai_params, @ollama_params = Transforms.normalize_params(params)
 
-          # Validations for Ollama-specific parameters
-          validate :validate_format
-          validate :validate_options_format
+            # Step 4: Validate Ollama-specific parameters
+            validate_format(@ollama_params[:format]) if @ollama_params[:format]
+            validate_options(@ollama_params[:options]) if @ollama_params[:options]
 
-          # Common Format Compatability
+            # Step 5: Create gem model with OpenAI-compatible params
+            gem_model = ::OpenAI::Models::Chat::CompletionCreateParams.new(**openai_params)
+
+            # Step 6: Delegate to the gem model
+            super(gem_model)
+          rescue ArgumentError => e
+            raise ArgumentError, "Invalid Ollama Chat request parameters: #{e.message}"
+          end
+
+          # Serializes request for API submission
+          #
+          # Merges OpenAI-compatible parameters with Ollama-specific extensions.
+          #
+          # @return [Hash] cleaned request hash
+          def serialize
+            # Get OpenAI params from gem model
+            openai_hash = Transforms.gem_to_hash(__getobj__)
+
+            # Merge with Ollama-specific params
+            Transforms.cleanup_serialized_request(openai_hash, @ollama_params, DEFAULTS, __getobj__)
+          end
+
+          # @return [Array<Hash>, nil]
+          def messages
+            __getobj__.instance_variable_get(:@data)[:messages]
+          end
+
+          # Sets messages with normalization
+          #
+          # Merges new messages with existing ones for compatibility.
+          #
+          # @param value [Array, String, Hash]
+          # @return [void]
           def messages=(value)
-            case value
-            when Array
-              super((messages || []) | value)
-            else
-              super((messages || []) | [ value ])
-            end
+            normalized_value = Transforms.normalize_messages(value)
+            current_messages = messages || []
+
+            # Merge behavior for Ollama compatibility
+            merged = current_messages | Array(normalized_value)
+            __getobj__.instance_variable_get(:@data)[:messages] = merged
+          end
+
+          # Alias for messages (common format compatibility)
+          #
+          # @return [Array<Hash>, nil]
+          def message
+            messages
+          end
+
+          # @param value [Array, String, Hash]
+          # @return [void]
+          def message=(value)
+            self.messages = value
+          end
+
+          # Sets instructions as developer messages
+          #
+          # Prepends developer messages to the messages array.
+          #
+          # @param values [Array<String>, String]
+          # @return [void]
+          def instructions=(*values)
+            instructions_messages = Transforms.normalize_instructions(values.flatten)
+            current_messages = messages || []
+            self.messages = instructions_messages + current_messages
+          end
+
+          # Accessor for Ollama format parameter
+          #
+          # @return [String, Hash, nil]
+          def format
+            @ollama_params[:format]
+          end
+
+          # Sets format parameter
+          #
+          # @param value [String, Hash]
+          # @return [void]
+          def format=(value)
+            validate_format(value)
+            @ollama_params[:format] = value
+          end
+
+          # Accessor for Ollama options parameter
+          #
+          # @return [Hash, nil]
+          def options
+            @ollama_params[:options]
+          end
+
+          # Sets options parameter
+          #
+          # @param value [Hash]
+          # @return [void]
+          def options=(value)
+            validate_options(value)
+            @ollama_params[:options] = value
+          end
+
+          # Accessor for keep_alive parameter
+          #
+          # @return [String, Integer, nil]
+          def keep_alive
+            @ollama_params[:keep_alive] || DEFAULTS[:keep_alive]
+          end
+
+          # Sets keep_alive parameter
+          #
+          # @param value [String, Integer]
+          # @return [void]
+          def keep_alive=(value)
+            @ollama_params[:keep_alive] = value
+          end
+
+          # Accessor for raw parameter
+          #
+          # @return [Boolean]
+          def raw
+            @ollama_params[:raw] || DEFAULTS[:raw]
+          end
+
+          # Sets raw parameter
+          #
+          # @param value [Boolean]
+          # @return [void]
+          def raw=(value)
+            @ollama_params[:raw] = value
           end
 
           private
 
-          def validate_format
+          # @api private
+          # @param params [Hash]
+          # @return [Hash]
+          def apply_defaults(params)
+            # Apply defaults
+            DEFAULTS.each do |key, value|
+              params[key] = value unless params.key?(key)
+            end
+
+            params
+          end
+
+          # @api private
+          # @param format [String, Hash, nil]
+          # @raise [ArgumentError]
+          def validate_format(format)
             return if format.nil?
             return if format == "json"
             return if format.is_a?(Hash) # JSON schema object
 
-            errors.add(:format, "must be 'json' or a JSON schema object")
+            raise ArgumentError, "format must be 'json' or a JSON schema object"
           end
 
-          def validate_options_format
+          # @api private
+          # @param options [Hash, nil]
+          # @raise [ArgumentError]
+          def validate_options(options)
             return if options.nil?
 
             unless options.is_a?(Hash)
-              errors.add(:options, "must be a hash of model parameters")
+              raise ArgumentError, "options must be a hash of model parameters"
             end
           end
         end

data/lib/active_agent/providers/ollama/chat/transforms.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/keys"
+require_relative "../../open_ai/chat/transforms"
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Chat
+        # Provides transformation methods for normalizing Ollama parameters
+        # to work with OpenAI gem's native format plus Ollama extensions
+        #
+        # Leverages OpenAI::Chat::Transforms for base message normalization while
+        # adding handling for Ollama-specific parameters like format, options,
+        # keep_alive, and raw mode.
+        module Transforms
+          class << self
+            # Converts gem model object to hash via JSON round-trip
+            #
+            # @param gem_object [Object]
+            # @return [Hash] with symbolized keys
+            def gem_to_hash(gem_object)
+              OpenAI::Chat::Transforms.gem_to_hash(gem_object)
+            end
+
+            # Normalizes all request parameters for Ollama API
+            #
+            # Handles both OpenAI-compatible parameters and Ollama-specific extensions.
+            # Ollama-specific params (format, options, keep_alive, raw) are
+            # extracted and returned separately for manual serialization.
+            #
+            # @param params [Hash]
+            # @return [Array<Hash, Hash>] tuple of [openai_params, ollama_params]
+            def normalize_params(params)
+              params = params.dup
+
+              # Extract Ollama-specific parameters
+              ollama_params = {}
+              ollama_params[:format] = params.delete(:format) if params.key?(:format)
+              ollama_params[:options] = params.delete(:options) if params.key?(:options)
+              ollama_params[:keep_alive] = params.delete(:keep_alive) if params.key?(:keep_alive)
+              ollama_params[:raw] = params.delete(:raw) if params.key?(:raw)
+
+              # Use OpenAI transforms for the base parameters
+              openai_params = OpenAI::Chat::Transforms.normalize_params(params)
+
+              [ openai_params, ollama_params ]
+            end
+
+            # Normalizes messages using OpenAI transforms
+            #
+            # @param messages [Array, String, Hash, nil]
+            # @return [Array<OpenAI::Models::Chat::ChatCompletionMessageParam>, nil]
+            def normalize_messages(messages)
+              OpenAI::Chat::Transforms.normalize_messages(messages)
+            end
+
+            # Normalizes instructions using OpenAI transforms
+            #
+            # @param instructions [Array<String>, String]
+            # @return [Array<OpenAI::Models::Chat::ChatCompletionMessageParam>]
+            def normalize_instructions(instructions)
+              OpenAI::Chat::Transforms.normalize_instructions(instructions)
+            end
+
+            # Cleans up serialized request for API submission
+            #
+            # Merges OpenAI-compatible params with Ollama-specific params.
+            # Also groups consecutive same-role messages as required by Ollama.
+            #
+            # @param openai_hash [Hash] serialized OpenAI request
+            # @param ollama_params [Hash] Ollama-specific parameters
+            # @param defaults [Hash] default values to remove
+            # @param gem_object [Object] original gem object
+            # @return [Hash] cleaned and merged request hash
+            def cleanup_serialized_request(openai_hash, ollama_params, defaults, gem_object)
+              # Start with OpenAI cleanup
+              cleaned = OpenAI::Chat::Transforms.cleanup_serialized_request(openai_hash, defaults, gem_object)
+
+              # Group consecutive same-role messages for Ollama
+              if cleaned[:messages]
+                cleaned[:messages] = group_same_role_messages(cleaned[:messages])
+              end
+
+              # Merge Ollama-specific params, but skip default values
+              ollama_params.each do |key, value|
+                # Skip if value is nil, empty, or matches the default
+                next if value.nil?
+                next if value.respond_to?(:empty?) && value.empty?
+                next if defaults.key?(key) && defaults[key] == value
+
+                cleaned[key] = value
+              end
+
+              cleaned
+            end
+
+            # Groups consecutive same-role messages for Ollama
+            #
+            # Ollama requires consecutive messages with the same role to be merged
+            # by concatenating their content.
+            #
+            # @param messages [Array<Hash>] array of message hashes
+            # @return [Array<Hash>] grouped messages
+            def group_same_role_messages(messages)
+              return [] if messages.nil? || messages.empty?
+
+              grouped = []
+              messages.each do |message|
+                if grouped.empty? || grouped.last[:role] != message[:role]
+                  grouped << message.deep_dup
+                else
+                  # Concatenate content for same-role messages
+                  last_content = grouped.last[:content]
+                  new_content = message[:content]
+
+                  grouped.last[:content] = if last_content.is_a?(Array) && new_content.is_a?(Array)
+                    last_content + new_content
+                  elsif last_content.is_a?(String) && new_content.is_a?(String)
+                    last_content + new_content
+                  else
+                    # Mix of types, convert to array
+                    Array(last_content) + Array(new_content)
+                  end
+                end
+              end
+
+              grouped
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama/embedding/request.rb

@@ -1,74 +1,187 @@
 # frozen_string_literal: true
 
-require "active_agent/providers/common/model"
-require_relative "requests/_types"
+require "delegate"
+require "json"
+require_relative "transforms"
 
 module ActiveAgent
   module Providers
     module Ollama
       module Embedding
-        class Request < Common::BaseModel
-          # Model name to generate embeddings from (required)
-          attribute :model, :string
+        # Wraps OpenAI gem's EmbeddingCreateParams with Ollama-specific extensions
+        #
+        # Delegates to OpenAI::Models::EmbeddingCreateParams for OpenAI-compatible
+        # parameters while adding support for Ollama-specific features like options,
+        # keep_alive, and truncate.
+        #
+        # Ollama-specific parameters:
+        # - options: Additional model parameters (Hash with temperature, seed, etc.)
+        # - keep_alive: Controls how long model stays in memory (String duration)
+        # - truncate: Truncates input to fit context length (Boolean)
+        #
+        # @example Basic usage
+        #   request = Request.new(
+        #     model: "llama2",
+        #     input: "Hello world"
+        #   )
+        #
+        # @example With Ollama-specific features
+        #   request = Request.new(
+        #     model: "llama2",
+        #     input: ["Hello", "World"],
+        #     options: {temperature: 0.7, seed: 42},
+        #     keep_alive: "10m",
+        #     truncate: false
+        #   )
+        #
+        # @example With delegated option attributes
+        #   request = Request.new(
+        #     model: "llama2",
+        #     input: "Hello",
+        #     temperature: 0.7,  # Automatically goes to options
+        #     seed: 42           # Automatically goes to options
+        #   )
+        class Request < SimpleDelegator
+          # Default parameter values
+          DEFAULTS = {
+            truncate: true,
+            keep_alive: "5m"
+          }.freeze
+
+          # @return [Hash] Ollama-specific parameters
+          attr_reader :ollama_params
+
+          # Creates a new Ollama embedding request
+          #
+          # @param params [Hash] request parameters
+          # @option params [String] :model model identifier (required)
+          # @option params [String, Array<String>] :input text to embed (required)
+          # @option params [Hash] :options model-specific options
+          # @option params [String] :keep_alive memory duration
+          # @option params [Boolean] :truncate truncate to context length
+          # @option params [Float] :temperature delegated to options
+          # @option params [Integer] :seed delegated to options
+          # @raise [ArgumentError] when parameters are invalid
+          def initialize(**params)
+            # Step 1: Apply defaults
+            params = apply_defaults(params)
+
+            # Step 2: Validate presence of required params before normalization
+            raise ArgumentError, "model is required" unless params[:model]
+            raise ArgumentError, "input is required" unless params[:input]
+
+            # Step 3: Normalize parameters and split into OpenAI vs Ollama-specific
+            openai_params, @ollama_params = Transforms.normalize_params(params)
+
+            # Step 4: Create gem model with OpenAI-compatible params
+            gem_model = ::OpenAI::Models::EmbeddingCreateParams.new(**openai_params)
+
+            # Step 5: Delegate to the gem model
+            super(gem_model)
+          rescue ArgumentError => e
+            raise ArgumentError, "Invalid Ollama Embedding request parameters: #{e.message}"
+          end
 
-          # Input text or list of text to generate embeddings for (required)
-          # Can be a string or array of strings
-          attribute :input, Requests::InputType.new
+          # Serializes request for API submission
+          #
+          # Merges OpenAI-compatible parameters with Ollama-specific extensions.
+          #
+          # @return [Hash] cleaned request hash
+          def serialize
+            # Get OpenAI params from gem model
+            openai_hash = Transforms.gem_to_hash(__getobj__)
+
+            # Merge with Ollama-specific params
+            Transforms.cleanup_serialized_request(openai_hash, @ollama_params, DEFAULTS)
+          end
 
-          # Truncates the end of each input to fit within context length (optional)
-          # Returns error if false and context length is exceeded
-          # Defaults to true
-          attribute :truncate, :boolean, default: true
+          # Accessor for input parameter
+          #
+          # @return [Array<String>, nil]
+          def input
+            __getobj__.instance_variable_get(:@data)[:input]
+          end
 
-          # Additional model parameters listed in the documentation for the Modelfile (optional)
-          # such as temperature
-          attribute :options, Requests::OptionsType.new
+          # Sets input with normalization
+          #
+          # @param value [String, Array<String>]
+          # @return [void]
+          def input=(value)
+            normalized_value = Transforms.normalize_input(value)
+            __getobj__.instance_variable_get(:@data)[:input] = normalized_value
+          end
 
-          # Controls how long the model will stay loaded into memory following the request (optional)
-          # Default: 5m
-          attribute :keep_alive, :string
+          # Accessor for Ollama options parameter
+          #
+          # @return [Hash, nil]
+          def options
+            @ollama_params[:options]
+          end
 
-          # Validations
-          validates :model, :input, presence: true
+          # Sets options parameter
+          #
+          # @param value [Hash]
+          # @return [void]
+          def options=(value)
+            @ollama_params[:options] = value
+          end
 
-          # Custom validations
-          validate :validate_input_format
-          validate :validate_input_not_empty
+          # Accessor for keep_alive parameter
+          #
+          # @return [String, nil]
+          def keep_alive
+            @ollama_params[:keep_alive] || DEFAULTS[:keep_alive]
+          end
 
-          # To merge over global prompt/model options over
-          delegate_attributes :mirostat, :mirostat_eta, :mirostat_tau, :num_ctx, :repeat_last_n, :repeat_penalty,
-                              :temperature, :seed, :num_predict, :top_k, :top_p, :min_p,
-                              to: :options
+          # Sets keep_alive parameter
+          #
+          # @param value [String]
+          # @return [void]
+          def keep_alive=(value)
+            @ollama_params[:keep_alive] = value
+          end
 
-          private
+          # Accessor for truncate parameter
+          #
+          # @return [Boolean]
+          def truncate
+            @ollama_params.fetch(:truncate, DEFAULTS[:truncate])
+          end
 
-          def validate_input_format
-            return if input.nil?
+          # Sets truncate parameter
+          #
+          # @param value [Boolean]
+          # @return [void]
+          def truncate=(value)
+            @ollama_params[:truncate] = value
+          end
 
-            unless input.is_a?(Array)
-              errors.add(:input, "must be stored as an array internally")
-              return
+          # Delegated option attribute accessors
+          # These allow setting option values at the top level
+          %i[mirostat mirostat_eta mirostat_tau num_ctx repeat_last_n
+             repeat_penalty temperature seed num_predict top_k top_p min_p stop].each do |attr|
+            define_method(attr) do
+              options&.dig(attr)
             end
 
-            # Validate array contents - Ollama only accepts strings
-            input.each_with_index do |item, index|
-              unless item.is_a?(String)
-                errors.add(:input, "array elements must be strings at index #{index}")
-                next
-              end
-
-              if item.empty?
-                errors.add(:input, "cannot contain empty strings at index #{index}")
-              end
+            define_method(:"#{attr}=") do |value|
+              @ollama_params[:options] ||= {}
+              @ollama_params[:options][attr] = value
             end
           end
 
-          def validate_input_not_empty
-            return if input.nil?
+          private
 
-            if input.is_a?(Array) && input.empty?
-              errors.add(:input, "cannot be an empty array")
+          # @api private
+          # @param params [Hash]
+          # @return [Hash]
+          def apply_defaults(params)
+            # Apply defaults
+            DEFAULTS.each do |key, value|
+              params[key] = value unless params.key?(key)
             end
+
+            params
           end
         end
       end