activeagent 0.6.3 → 1.0.0

data/lib/active_agent/providers/mock/messages/_types.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Load all message classes
+require_relative "base"
+require_relative "user"
+require_relative "assistant"
+
+module ActiveAgent
+  module Providers
+    module Mock
+      module Messages
+        # Type for Messages array
+        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
+        class MessageType < ActiveModel::Type::Value
+          def cast(value)
+            case value
+            when Base
+              value
+            when String
+              User.new(content: value)
+            when Hash
+              hash = value.deep_symbolize_keys
+              role = hash[:role]&.to_sym
+
+              case role
+              when :user, nil
+                User.new(**hash)
+              when :assistant
+                Assistant.new(**hash)
+              else
+                raise ArgumentError, "Unknown message role: #{role}"
+              end
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to Message"
+            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

data/lib/active_agent/providers/mock/messages/assistant.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Mock
+      module Messages
+        # Assistant message for Mock provider.
+        #
+        # Drops extra fields that are part of the API response but not
+        # part of the message structure (usage, id, model, stop_reason, type, etc).
+        class Assistant < Base
+          attribute :role, :string, as: "assistant"
+          attribute :content # Can be string or array of content blocks
+          attribute :name, :string
+
+          validates :content, presence: true
+
+          # Drop API response fields that aren't part of the message
+          drop_attributes :usage, :id, :model, :stop_reason, :stop_sequence, :type
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/mock/messages/base.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Mock
+      module Messages
+        # Base class for Mock messages.
+        class Base < Common::BaseModel
+          attribute :role, :string
+          attribute :content
+
+          validates :role, presence: true
+
+          # Define content setter methods for different content types
+          %i[text image document].each do |content_type|
+            define_method(:"#{content_type}=") do |value|
+              # For mock provider, we keep content simple
+              # If it's text, just set content to the text value
+              if content_type == :text
+                self.content = value
+              else
+                # For image/document, MockProvider doesn't support these, so ignore
+                # (or could raise an error)
+              end
+            end
+          end
+
+          # Converts to common format.
+          #
+          # @return [Hash] message in canonical format with role and text content
+          def to_common
+            {
+              role: role,
+              content: extract_text_content,
+              name: nil
+            }
+          end
+
+          private
+
+          # Extracts text content from the content structure.
+          #
+          # @return [String] extracted text content
+          def extract_text_content
+            case content
+            when String
+              content
+            when Array
+              # Join all text blocks
+              content.select { |block| block.is_a?(Hash) && block[:type] == "text" }
+                     .map { |block| block[:text] }
+                     .join("\n")
+            else
+              content.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/mock/messages/user.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Mock
+      module Messages
+        # User message for Mock provider.
+        class User < Base
+          attribute :role, :string, as: "user"
+
+          validates :content, presence: true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Mock
+      # Configuration options for the Mock provider.
+      #
+      # This provider doesn't make real API calls, so most options are unused.
+      # Included for consistency with other providers.
+      class Options < Common::BaseModel
+        attribute :base_url, :string, default: "https://mock.example.com"
+        attribute :api_key, :string, default: "mock-api-key"
+
+        # Common Interface Compatibility
+        alias_attribute :access_token, :api_key
+
+        def initialize(kwargs = {})
+          kwargs = kwargs.deep_symbolize_keys if kwargs.respond_to?(:deep_symbolize_keys)
+          super(**deep_compact(kwargs))
+        end
+
+        def extra_headers
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/mock/request.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+require_relative "messages/_types"
+
+module ActiveAgent
+  module Providers
+    module Mock
+      # Request model for Mock provider.
+      #
+      # Simplified request model that accepts messages and basic parameters.
+      class Request < Common::BaseModel
+        # Required parameters
+        attribute :model, :string, default: "mock-model"
+        attribute :messages, Messages::MessagesType.new
+
+        # Optional parameters
+        attribute :instructions # System instructions
+        attribute :temperature, :float
+        attribute :max_tokens, :integer
+        attribute :stream, :boolean, default: false
+        attribute :tools # Array of tool definitions
+        attribute :tool_choice # Tool choice configuration
+
+        # Common Format Compatibility
+        def message=(value)
+          self.messages ||= []
+          self.messages << value
+        end
+
+        def response_format
+          { type: "text" }
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/mock_provider.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require_relative "_base_provider"
+require_relative "mock/_types"
+
+module ActiveAgent
+  module Providers
+    # Mock provider for testing purposes.
+    #
+    # This provider doesn't make real API calls. Instead, it returns the last
+    # message content converted to pig latin for prompts, and random data for embeddings.
+    # Useful for testing without incurring API costs or requiring network access.
+    #
+    # @example Basic usage
+    #   provider = ActiveAgent::Providers::MockProvider.new(...)
+    #   result = provider.prompt
+    #
+    # @see BaseProvider
+    class MockProvider < BaseProvider
+      # Returns the embedding request type for Mock.
+      #
+      # @return [ActiveModel::Type::Value] The Mock embedding request type
+      def self.embed_request_type
+        Mock::EmbeddingRequestType.new
+      end
+
+      # Returns a mock client (just returns self since we don't need a real client).
+      #
+      # @return [MockProvider] Returns self
+      def client
+        self
+      end
+
+      protected
+
+      # Executes a mock prompt request.
+      #
+      # Extracts the last user message, converts it to pig latin, and returns
+      # a mock response structure. Handles both streaming and non-streaming.
+      #
+      # @param parameters [Hash] The prompt request parameters
+      # @return [Hash] A mock API response structure
+      def api_prompt_execute(parameters)
+        # Extract the last message content
+        last_message = [ request.instructions, parameters[:messages]&.last&.dig(:content) ].compact.join(" ")
+        content = extract_message_content(last_message)
+
+        # Convert to pig latin
+        pig_latin_content = to_pig_latin(content)
+
+        if parameters[:stream]
+          # For streaming, call the stream proc with chunks
+          stream_proc = parameters[:stream]
+          simulate_streaming(pig_latin_content, stream_proc)
+          nil
+        else
+          # Return a complete response
+          {
+            "id" => "mock-#{SecureRandom.hex(8)}",
+            "type" => "message",
+            "role" => "assistant",
+            "content" => [
+              {
+                "type" => "text",
+                "text" => pig_latin_content
+              }
+            ],
+            "model" => parameters[:model] || "mock-model",
+            "stop_reason" => "end_turn",
+            "usage" => {
+              "input_tokens" => content.length,
+              "output_tokens" => pig_latin_content.length
+            }
+          }
+        end
+      end
+
+      # Executes a mock embedding request.
+      #
+      # Returns random embedding vectors for testing purposes.
+      #
+      # @param parameters [Hash] The embedding request parameters
+      # @return [Hash] A mock embedding response structure with symbol keys
+      def api_embed_execute(parameters)
+        input = parameters[:input]
+        inputs = input.is_a?(Array) ? input : [ input ]
+        dimensions = parameters[:dimensions] || 1536
+
+        {
+          "object" => "list",
+          "data" => inputs.map.with_index do |text, index|
+            {
+              "object" => "embedding",
+              "index" => index,
+              "embedding" => generate_random_embedding(dimensions)
+            }
+          end,
+          "model" => parameters[:model] || "mock-embedding-model",
+          "usage" => {
+            "prompt_tokens" => inputs.sum { |text| text.to_s.length },
+            "total_tokens" => inputs.sum { |text| text.to_s.length }
+          }
+        }.deep_symbolize_keys
+      end
+
+      # Processes streaming response chunks.
+      #
+      # Handles mock streaming chunks, similar to real provider implementations.
+      #
+      # @param api_response_chunk [Hash] The streaming response chunk
+      # @return [void]
+      def process_stream_chunk(api_response_chunk)
+        chunk_type = api_response_chunk[:type]&.to_sym
+
+        instrument("stream_chunk.active_agent", chunk_type: chunk_type)
+
+        broadcast_stream_open
+
+        case chunk_type
+        when :message_start
+          api_message = api_response_chunk[:message]
+          message_stack.push(api_message)
+          broadcast_stream_update(message_stack.last)
+
+        when :content_block_start
+          api_content = api_response_chunk[:content_block]
+          message_stack.last[:content] ||= []
+          message_stack.last[:content].push(api_content)
+          broadcast_stream_update(message_stack.last, api_content[:text])
+
+        when :content_block_delta
+          index = api_response_chunk[:index]
+          content = message_stack.last[:content][index]
+          delta = api_response_chunk[:delta]
+
+          if delta[:type] == "text_delta"
+            content[:text] ||= ""
+            content[:text] += delta[:text]
+            broadcast_stream_update(message_stack.last, delta[:text])
+          end
+
+        when :message_delta
+          delta = api_response_chunk[:delta]
+          message_stack.last[:stop_reason] = delta[:stop_reason] if delta[:stop_reason]
+
+        when :message_stop
+          # Stream complete
+        end
+      end
+
+      # Extracts messages from API response.
+      #
+      # @param api_response [Hash] The API response
+      # @return [Array<Hash>] Array of message hashes
+      def process_prompt_finished_extract_messages(api_response)
+        return nil if api_response.nil? # Streaming case
+        [ api_response ]
+      end
+
+      # Extracts function calls from API response.
+      #
+      # Mock provider doesn't support tool calling by default.
+      #
+      # @return [nil]
+      def process_prompt_finished_extract_function_calls
+        nil
+      end
+
+      private
+
+      # Extracts text content from a message.
+      #
+      # @param message [Hash, String, nil] The message to extract from
+      # @return [String] The extracted text content
+      def extract_message_content(message)
+        return "" if message.nil?
+
+        case message
+        when String
+          message
+        when Hash
+          if message[:content].is_a?(String)
+            message[:content]
+          elsif message[:content].is_a?(Array)
+            message[:content]
+              .select { |block| block.is_a?(Hash) && block[:type] == "text" }
+              .map { |block| block[:text] }
+              .join(" ")
+          else
+            message[:content].to_s
+          end
+        else
+          message.to_s
+        end
+      end
+
+      # Converts text to pig latin.
+      #
+      # Simple pig latin conversion:
+      # - Words starting with vowels: add "way" to the end
+      # - Words starting with consonants: move consonants to end and add "ay"
+      # - Preserves punctuation and capitalization
+      #
+      # @param text [String] The text to convert
+      # @return [String] The text in pig latin
+      def to_pig_latin(text)
+        return "" if text.nil? || text.empty?
+
+        words = text.split(/\b/)
+
+        words.map do |word|
+          # Skip non-word characters (spaces, punctuation, etc.)
+          next word unless word.match?(/\w/)
+
+          # Check if word starts with a vowel
+          if word.match?(/^[aeiouAEIOU]/)
+            "#{word}way"
+          else
+            # Find the first vowel
+            match = word.match(/^([^aeiouAEIOU]+)(.*)/)
+            if match
+              consonants = match[1]
+              rest = match[2]
+
+              # Preserve capitalization
+              if word[0] == word[0].upcase && rest.length > 0
+                "#{rest[0].upcase}#{rest[1..-1]}#{consonants.downcase}ay"
+              else
+                "#{rest}#{consonants}ay"
+              end
+            else
+              # No vowels found, just add "ay"
+              "#{word}ay"
+            end
+          end
+        end.join
+      end
+
+      # Simulates streaming by sending chunks.
+      #
+      # @param content [String] The full content to stream
+      # @param stream_proc [Proc] The streaming callback
+      # @return [void]
+      def simulate_streaming(content, stream_proc)
+        message_id = "mock-#{SecureRandom.hex(8)}"
+
+        # Send message_start
+        stream_proc.call({
+          type: :message_start,
+          message: {
+            id: message_id,
+            type: "message",
+            role: "assistant",
+            content: [],
+            model: "mock-model"
+          }
+        })
+
+        # Send content_block_start
+        stream_proc.call({
+          type: :content_block_start,
+          index: 0,
+          content_block: {
+            type: "text",
+            text: ""
+          }
+        })
+
+        # Send content in chunks (simulate word-by-word streaming)
+        words = content.split(" ")
+        words.each_with_index do |word, i|
+          text_chunk = i == 0 ? word : " #{word}"
+          stream_proc.call({
+            type: :content_block_delta,
+            index: 0,
+            delta: {
+              type: "text_delta",
+              text: text_chunk
+            }
+          })
+        end
+
+        # Send message_delta with stop_reason
+        stream_proc.call({
+          type: :message_delta,
+          delta: {
+            stop_reason: "end_turn"
+          }
+        })
+
+        # Send message_stop
+        stream_proc.call({
+          type: :message_stop
+        })
+      end
+
+      # Generates a random embedding vector.
+      #
+      # @param dimensions [Integer] The number of dimensions for the embedding
+      # @return [Array<Float>] A random normalized vector
+      def generate_random_embedding(dimensions)
+        # Generate random values between -1 and 1
+        vector = Array.new(dimensions) { rand * 2 - 1 }
+
+        # Normalize the vector to unit length (common for embeddings)
+        magnitude = Math.sqrt(vector.sum { |v| v ** 2 })
+        vector.map { |v| v / magnitude }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "options"
+require_relative "chat/_types"
+require_relative "embedding/_types"

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