activeagent 1.0.0.rc1 → 1.0.0

data/lib/active_agent/providers/anthropic/requests/thinking_config/_types.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "enabled"
-require_relative "disabled"
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ThinkingConfig
-          # Type for ThinkingConfig
-          class ThinkingConfigType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when Base
-                value
-              when Hash
-                hash = value.deep_symbolize_keys
-                type = hash[:type]&.to_sym
-
-                case type
-                when :enabled
-                  Enabled.new(**hash)
-                when :disabled
-                  Disabled.new(**hash)
-                when nil
-                  nil
-                else
-                  raise ArgumentError, "Unknown thinking config type: #{type}"
-                end
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to ThinkingConfig"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when Base
-                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/anthropic/requests/thinking_config/base.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "active_agent/providers/common/model"
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ThinkingConfig
-          # Base class for thinking configuration
-          class Base < Common::BaseModel
-            attribute :type, :string
-
-            validates :type, presence: true, inclusion: { in: %w[enabled disabled] }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/anthropic/requests/thinking_config/disabled.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ThinkingConfig
-          # Disabled thinking configuration
-          class Disabled < Base
-            attribute :type, :string, as: "disabled"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/anthropic/requests/thinking_config/enabled.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ThinkingConfig
-          # Enabled thinking configuration with budget
-          class Enabled < Base
-            attribute :type,          :string,  as: "enabled"
-            attribute :budget_tokens, :integer
-
-            validates :budget_tokens, presence: true
-            validates :budget_tokens, numericality: { greater_than_or_equal_to: 1024 }, allow_nil: false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/anthropic/requests/tool_choice/_types.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "auto"
-require_relative "any"
-require_relative "tool"
-require_relative "none"
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ToolChoice
-          # Type for ToolChoice
-          class ToolChoiceType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when Base
-                value
-              when Hash
-                hash = value.deep_symbolize_keys
-                type = hash[:type]&.to_sym
-
-                case type
-                when :auto
-                  Auto.new(**hash)
-                when :any
-                  Any.new(**hash)
-                when :tool
-                  Tool.new(**hash)
-                when :none
-                  None.new(**hash)
-                when nil
-                  nil
-                else
-                  raise ArgumentError, "Unknown tool choice type: #{type}"
-                end
-              when String, Symbol
-                # Allow string shortcuts like "auto", "any", "none"
-                case value.to_sym
-                when :auto
-                  Auto.new
-                when :any
-                  Any.new
-                when :none
-                  None.new
-                else
-                  raise ArgumentError, "Unknown tool choice: #{value}"
-                end
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to ToolChoice"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when Base
-                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/anthropic/requests/tool_choice/any.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ToolChoice
-          # Any tool choice - model will use any available tools
-          class Any < Base
-            attribute :type,                      :string,  as: "any"
-            attribute :disable_parallel_tool_use, :boolean
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/anthropic/requests/tool_choice/auto.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ToolChoice
-          # Auto tool choice - model decides whether to use tools
-          class Auto < Base
-            attribute :type,                      :string,  as: "auto"
-            attribute :disable_parallel_tool_use, :boolean
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/anthropic/requests/tool_choice/base.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "active_agent/providers/common/model"
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ToolChoice
-          # Base class for tool choice configurations
-          class Base < Common::BaseModel
-            attribute :type, :string
-
-            validates :type, presence: true, inclusion: { in: %w[auto any tool none] }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/anthropic/requests/tool_choice/none.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ToolChoice
-          # None tool choice - model will not use tools
-          class None < Base
-            attribute :type, :string, as: "none"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/anthropic/requests/tool_choice/tool.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Providers
-    module Anthropic
-      module Requests
-        module ToolChoice
-          # Tool choice - model will use the specified tool
-          class Tool < Base
-            attribute :type,                      :string, as: "tool"
-            attribute :name,                      :string
-            attribute :disable_parallel_tool_use, :boolean
-
-            validates :name, presence: true
-          end
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,116 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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/requests/_types.rb

@@ -1,83 +0,0 @@
-# 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

@@ -1,104 +0,0 @@
-# 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