activeagent 0.6.3 → 1.0.0.rc1

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "request"
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Chat
+        # Type for Request model
+        class RequestType < ActiveModel::Type::Value
+          def cast(value)
+            case value
+            when Request
+              value
+            when Hash
+              Request.new(**value.deep_symbolize_keys)
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to Request"
+            end
+          end
+
+          def serialize(value)
+            case value
+            when Request
+              value.serialize
+            when Hash
+              value
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot serialize #{value.class}"
+            end
+          end
+
+          def deserialize(value)
+            cast(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../../open_ai/chat/request"
+require_relative "requests/_types"
+
+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
+
+          # Ollama-specific parameters
+
+          # Format: return response in json or as a JSON schema
+          # Can be "json" or a JSON schema object
+          attribute :format
+
+          # Options: additional model parameters (temperature, num_predict, etc.)
+          # Hash of key-value pairs for model-specific options
+          attribute :options
+
+          # 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
+
+          # 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
+
+          # Validations for Ollama-specific parameters
+          validate :validate_format
+          validate :validate_options_format
+
+          # Common Format Compatability
+          def messages=(value)
+            case value
+            when Array
+              super((messages || []) | value)
+            else
+              super((messages || []) | [ value ])
+            end
+          end
+
+          private
+
+          def validate_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")
+          end
+
+          def validate_options_format
+            return if options.nil?
+
+            unless options.is_a?(Hash)
+              errors.add(:options, "must be a hash of model parameters")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama/chat/requests/_types.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "messages/_types"

data/lib/active_agent/providers/ollama/chat/requests/messages/_types.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/open_ai/chat/requests/messages/_types"
+
+require_relative "assistant"
+require_relative "user"
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Chat
+        module Requests
+          module Messages
+            # Type for Messages array - uses Ollama's MessageType
+            class MessagesType < ActiveModel::Type::Value
+              def initialize
+                super
+                @message_type = MessageType.new
+              end
+
+              def cast(value)
+                case value
+                when Array
+                  value.map { |v| @message_type.cast(v) }
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot cast #{value.class} to Messages array"
+                end
+              end
+
+              def serialize(value)
+                case value
+                when Array
+                  grouped = []
+
+                  value.each do |message|
+                    if grouped.empty? || grouped.last.role != message.role
+                      grouped << message.deep_dup
+                    else
+                      grouped.last.content += message.content.deep_dup
+                    end
+                  end
+
+                  grouped.map { |v| @message_type.serialize(v) }
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot serialize #{value.class}"
+                end
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+            end
+
+            # Type for individual Message
+            # Inherits from OpenAI but handles Ollama-specific message types
+            class MessageType < OpenAI::Chat::Requests::Messages::MessageType
+              def cast(value)
+                case value
+                when Assistant, User
+                  value
+                when OpenAI::Chat::Requests::Messages::Base
+                  value
+                when String
+                  User.new(content: value)
+                when Hash
+                  hash = value.deep_symbolize_keys
+                  role = hash[:role]&.to_sym
+
+                  case role
+                  when :assistant
+                    Assistant.new(**hash)
+                  when :user, nil
+                    User.new(**hash)
+                  when :system
+                    OpenAI::Chat::Requests::Messages::System.new(**hash)
+                  when :developer
+                    OpenAI::Chat::Requests::Messages::Developer.new(**hash)
+                  when :tool
+                    OpenAI::Chat::Requests::Messages::Tool.new(**hash)
+                  else
+                    raise ArgumentError, "Unknown message role: #{role.inspect}"
+                  end
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot cast #{value.class} to Message (expected Assistant, User, OpenAI Message, Hash, or nil)"
+                end
+              end
+
+              def serialize(value)
+                case value
+                when OpenAI::Chat::Requests::Messages::Base
+                  value.serialize
+                when Hash
+                  value
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot serialize #{value.class} as Message"
+                end
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama/chat/requests/messages/assistant.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Chat
+        module Requests
+          module Messages
+            # Assistant message - messages sent by the model
+            # Inherits from OpenAI base as Ollama is largely compatible
+            class Assistant < OpenAI::Chat::Requests::Messages::Assistant
+              drop_attributes :reasoning
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama/chat/requests/messages/user.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Chat
+        module Requests
+          module Messages
+            # User message - messages sent by an end user
+            # Ollama has the same user message format as OpenAI
+            class User < OpenAI::Chat::Requests::Messages::User
+              attribute :images # Array of base64 encoded images
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "request"
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Embedding
+        # Type for Request model
+        class RequestType < ActiveModel::Type::Value
+          def cast(value)
+            case value
+            when Request
+              value
+            when Hash
+              Request.new(**value.deep_symbolize_keys)
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to Request"
+            end
+          end
+
+          def serialize(value)
+            case value
+            when Request
+              value.serialize
+            when Hash
+              value
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot serialize #{value.class}"
+            end
+          end
+
+          def deserialize(value)
+            cast(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+require_relative "requests/_types"
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Embedding
+        class Request < Common::BaseModel
+          # Model name to generate embeddings from (required)
+          attribute :model, :string
+
+          # Input text or list of text to generate embeddings for (required)
+          # Can be a string or array of strings
+          attribute :input, Requests::InputType.new
+
+          # 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
+
+          # Additional model parameters listed in the documentation for the Modelfile (optional)
+          # such as temperature
+          attribute :options, Requests::OptionsType.new
+
+          # Controls how long the model will stay loaded into memory following the request (optional)
+          # Default: 5m
+          attribute :keep_alive, :string
+
+          # Validations
+          validates :model, :input, presence: true
+
+          # Custom validations
+          validate :validate_input_format
+          validate :validate_input_not_empty
+
+          # 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
+
+          private
+
+          def validate_input_format
+            return if input.nil?
+
+            unless input.is_a?(Array)
+              errors.add(:input, "must be stored as an array internally")
+              return
+            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
+            end
+          end
+
+          def validate_input_not_empty
+            return if input.nil?
+
+            if input.is_a?(Array) && input.empty?
+              errors.add(:input, "cannot be an empty array")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama/embedding/requests/_types.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "options"
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Embedding
+        module Requests
+          # Custom type for handling embedding input
+          # Ollama only accepts strings or arrays of strings (no token arrays)
+          class InputType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when String
+                [ value.presence ].compact
+              when Array
+                value.compact
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Input (expected String or Array)"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Array
+                # Return single string if array has only one string element
+                if value in [ String => string ]
+                  string
+                else
+                  value
+                end
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class} as Input"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+
+          # Custom type for handling options
+          class OptionsType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when Options
+                value
+              when Hash
+                Options.new(**value.symbolize_keys)
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Options"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Options
+                value.serialize
+              when Hash
+                value
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama/embedding/requests/options.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      module Embedding
+        module Requests
+          class Options < Common::BaseModel
+            # Enable Mirostat sampling for controlling perplexity
+            # 0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0 (default: 0)
+            attribute :mirostat, :integer
+
+            # Influences how quickly the algorithm responds to feedback from the generated text
+            # Lower learning rate = slower adjustments, higher = more responsive (default: 0.1)
+            attribute :mirostat_eta, :float
+
+            # Controls the balance between coherence and diversity of the output
+            # Lower value = more focused and coherent text (default: 5.0)
+            attribute :mirostat_tau, :float
+
+            # Sets the size of the context window used to generate the next token (default: 2048)
+            attribute :num_ctx, :integer
+
+            # Sets how far back for the model to look back to prevent repetition
+            # Default: 64, 0 = disabled, -1 = num_ctx
+            attribute :repeat_last_n, :integer
+
+            # Sets how strongly to penalize repetitions
+            # Higher value (e.g., 1.5) = stronger penalty, lower (e.g., 0.9) = more lenient (default: 1.1)
+            attribute :repeat_penalty, :float
+
+            # The temperature of the model
+            # Higher temperature = more creative answers (default: 0.8)
+            attribute :temperature, :float
+
+            # Sets the random number seed to use for generation
+            # Setting this to a specific number will make the model generate the same text for the same prompt (default: 0)
+            attribute :seed, :integer
+
+            # Sets the stop sequences to use
+            # When this pattern is encountered the LLM will stop generating text and return
+            # Can be a string or array of strings
+            attribute :stop
+
+            # Maximum number of tokens to predict when generating text
+            # Default: -1 (infinite generation)
+            attribute :num_predict, :integer
+
+            # Reduces the probability of generating nonsense
+            # Higher value (e.g. 100) = more diverse answers, lower (e.g. 10) = more conservative (default: 40)
+            attribute :top_k, :integer
+
+            # Works together with top-k
+            # Higher value (e.g., 0.95) = more diverse text, lower (e.g., 0.5) = more focused and conservative (default: 0.9)
+            attribute :top_p, :float
+
+            # Alternative to the top_p, and aims to ensure a balance of quality and variety
+            # Represents the minimum probability for a token to be considered, relative to the probability of the most likely token
+            # For example, with p=0.05 and the most likely token having a probability of 0.9,
+            # logits with a value less than 0.045 are filtered out (default: 0.0)
+            attribute :min_p, :float
+
+            # Validations
+            validates :mirostat,       inclusion: { in: [ 0, 1, 2 ] },                                          allow_nil: true
+            validates :mirostat_eta,   numericality: { greater_than_or_equal_to: 0 },                           allow_nil: true
+            validates :mirostat_tau,   numericality: { greater_than_or_equal_to: 0 },                           allow_nil: true
+            validates :num_ctx,        numericality: { greater_than: 0, only_integer: true },                   allow_nil: true
+            validates :repeat_last_n,  numericality: { greater_than_or_equal_to: -1, only_integer: true },      allow_nil: true
+            validates :repeat_penalty, numericality: { greater_than: 0 },                                       allow_nil: true
+            validates :temperature,    numericality: { greater_than_or_equal_to: 0 },                           allow_nil: true
+            validates :seed,           numericality: { only_integer: true },                                    allow_nil: true
+            validates :num_predict,    numericality: { greater_than_or_equal_to: -1, only_integer: true },      allow_nil: true
+            validates :top_k,          numericality: { greater_than: 0, only_integer: true },                   allow_nil: true
+            validates :top_p,          numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 1 }, allow_nil: true
+            validates :min_p,          numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 1 }, allow_nil: true
+
+            validate :validate_stop_format
+
+            private
+
+            def validate_stop_format
+              return if stop.nil?
+
+              unless stop.is_a?(String) || stop.is_a?(Array)
+                errors.add(:stop, "must be a string or array of strings")
+                return
+              end
+
+              if stop.is_a?(Array)
+                stop.each_with_index do |item, index|
+                  unless item.is_a?(String)
+                    errors.add(:stop, "array elements must be strings at index #{index}")
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama/options.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/options"
+
+module ActiveAgent
+  module Providers
+    module Ollama
+      class Options < ActiveAgent::Providers::OpenAI::Options
+        attribute :base_url, :string, fallback: "http://127.0.0.1:11434/v1"
+        attribute :api_key,  :string, fallback: "ollama"
+
+        private
+
+        def resolve_api_key(kwargs)
+          kwargs[:api_key] ||
+            kwargs[:access_token] ||
+            ENV["OLLAMA_API_KEY"] ||
+            ENV["OLLAMA_ACCESS_TOKEN"]
+        end
+
+        # Not Used as Part of Ollama
+        def resolve_organization_id(settings) = nil
+        def resolve_project_id(settings)      = nil
+      end
+    end
+  end
+end