activeagent 0.6.0rc4 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 805b4d2cce3173788f3bb281e40973d8782891937b5220654b7dad53a9f701ec
-  data.tar.gz: 968f534f94d4e32541f1d87e21854add0f4bf8c9e851ba75f7599291a0b384b9
+  metadata.gz: 974e983d62e399bd41c40a34fc0869730d157a8361d74236e327b9aea7cd05e2
+  data.tar.gz: 827c43ed21428ddc4138ecb8465af4265d432fbe3b3ca666f46f1b92b3598a44
 SHA512:
-  metadata.gz: ec13c2dd2d8deb4fd4adb1a6f302de6a7bb5057fad1cd45f27fdecc6b8bea7b5496f3078e7a1f40168de9b4efaa8e4a2abf1cf1bd2865fa929912c58adce561c
-  data.tar.gz: a564772159ac558c8350d770977fc9b7b509c814435a748cac61af89bd87dc196614b45cc9f33db7bce8951568f659730bfe4cf95fd274f145ae00bb78510af6
+  metadata.gz: 7ede550eb0aae62274dd13b631f862f202b172bb6ba40f837358bac71cc58760edc444722bc5a0aea747760b6317cf33630754992866fdc439a8263c1b670c03
+  data.tar.gz: 80671e11f47c81ef591ed496c9a1ee126f32762d588787d3cd15a79eaf229f7da0b1c8e69cedfbd33509df92030a399ae2faaa5c346f9cf1cbedfdc25ee80819

data/README.md

@@ -2,9 +2,9 @@
   <source media="(prefers-color-scheme: dark)" srcset="https://github.com/user-attachments/assets/2bad263a-c09f-40b6-94ba-fff8e346d65d">
   <img alt="activeagents_banner" src="https://github.com/user-attachments/assets/0ebbaa2f-c6bf-4d40-bb77-931015a14be3">
 </picture>
-*Build AI in Rails*
 
 
+> *Build AI in Rails*
 >
 > *Now Agents are Controllers*
 >

data/lib/active_agent/action_prompt/base.rb

@@ -36,6 +36,9 @@ module ActiveAgent
 
       helper ActiveAgent::PromptHelper
 
+      # Delegate response to generation_provider for easy access in callbacks
+      delegate :response, to: :generation_provider, allow_nil: true
+
       class_attribute :options
 
       class_attribute :default_params, default: {
@@ -280,7 +283,7 @@ module ActiveAgent
       def initialize # :nodoc:
         super
         @_prompt_was_called = false
-        @_context = ActiveAgent::ActionPrompt::Prompt.new(options: self.class.options || {}, agent_instance: self)
+        @_context = ActiveAgent::ActionPrompt::Prompt.new(options: self.class.options&.deep_dup || {}, agent_instance: self)
       end
 
       def process(method_name, *args) # :nodoc:
@@ -444,7 +447,10 @@ module ActiveAgent
           :presence_penalty, :response_format, :seed, :stop, :tools_choice, :plugins,
 
           # OpenRouter Provider Settings
-          :data_collection, :require_parameters, :only, :ignore, :quantizations, :sort, :max_price
+          :data_collection, :require_parameters, :only, :ignore, :quantizations, :sort, :max_price,
+
+          # Built-in Tools Support (OpenAI Responses API)
+          :tools
         )
         # Handle explicit options parameter
         explicit_options = prompt_options[:options] || {}

data/lib/active_agent/action_prompt/message.rb

@@ -18,7 +18,7 @@ module ActiveAgent
       end
       VALID_ROLES = %w[system assistant user tool].freeze
 
-      attr_accessor :action_id, :action_name, :raw_actions, :generation_id, :content, :role, :action_requested, :requested_actions, :content_type, :charset, :metadata
+      attr_accessor :action_id, :action_name, :raw_actions, :generation_id, :content, :raw_content, :role, :action_requested, :requested_actions, :content_type, :charset, :metadata
 
       def initialize(attributes = {})
         @action_id = attributes[:action_id]
@@ -26,8 +26,9 @@ module ActiveAgent
         @generation_id = attributes[:generation_id]
         @metadata = attributes[:metadata] || {}
         @charset = attributes[:charset] || "UTF-8"
-        @content = attributes[:content] || ""
+        @raw_content = attributes[:content] || ""
         @content_type = detect_content_type(attributes)
+        @content = parse_content(@raw_content, @content_type)
         @role = attributes[:role] || :user
         @raw_actions = attributes[:raw_actions]
         @requested_actions = attributes[:requested_actions] || []
@@ -85,6 +86,20 @@ module ActiveAgent
 
       private
 
+      def parse_content(content, content_type)
+        # Auto-parse JSON content if content_type indicates JSON
+        if content_type&.match?(/json/i) && content.is_a?(String) && !content.empty?
+          begin
+            JSON.parse(content)
+          rescue JSON::ParserError
+            # If parsing fails, return the raw content
+            content
+          end
+        else
+          content
+        end
+      end
+
       def detect_content_type(attributes)
         # If content_type is explicitly provided, use it
         return attributes[:content_type] if attributes[:content_type]

data/lib/active_agent/callbacks.rb

@@ -7,6 +7,7 @@ module ActiveAgent
     included do
       include ActiveSupport::Callbacks
       define_callbacks :generation, skip_after_callbacks_if_terminated: true
+      define_callbacks :embedding, skip_after_callbacks_if_terminated: true
     end
 
     module ClassMethods
@@ -18,6 +19,14 @@ module ActiveAgent
             set_callback(:generation, callback, name, options)
           end
         end
+
+        # # Defines a callback that will get called right before/after/around the
+        # # embedding provider method.
+        define_method "#{callback}_embedding" do |*names, &blk|
+          _insert_callbacks(names, blk) do |name, options|
+            set_callback(:embedding, callback, name, options)
+          end
+        end
       end
     end
   end

data/lib/active_agent/generation.rb

@@ -50,6 +50,18 @@ module ActiveAgent
       end
     end
 
+    def embed_now
+      processed_agent.handle_exceptions do
+        processed_agent.run_callbacks(:embedding) do
+          processed_agent.embed
+        end
+      end
+    end
+
+    def embed_later(options = {})
+      enqueue_generation :embed_now, options
+    end
+
     private
 
     def processed_agent

data/lib/active_agent/generation_provider/anthropic_provider.rb

@@ -4,7 +4,7 @@ begin
   gem "ruby-anthropic", "~> 0.4.2"
   require "anthropic"
 rescue LoadError
-  raise LoadError, "The 'ruby-anthropic' gem is required for AnthropicProvider. Please add it to your Gemfile and run `bundle install`."
+  raise LoadError, "The 'ruby-anthropic ~> 0.4.2' gem is required for AnthropicProvider. Please add it to your Gemfile and run `bundle install`."
 end
 
 require "active_agent/action_prompt/action"
@@ -130,6 +130,7 @@ module ActiveAgent
 
         message = ActiveAgent::ActionPrompt::Message.new(
           content: content,
+          content_type: prompt.output_schema.present? ? "application/json" : "text/plain",
           role: "assistant",
           action_requested: response["stop_reason"] == "tool_use",
           requested_actions: handle_actions(response["content"].map { |c| c if c["type"] == "tool_use" }.reject { |m| m.blank? }.to_a),

data/lib/active_agent/generation_provider/error_handling.rb

@@ -60,7 +60,7 @@ module ActiveAgent
       end
 
       def format_error_message(error)
-        message = if error.respond_to?(:response)
+        message = if error.respond_to?(:response) && error.response
           error.response[:body]
         elsif error.respond_to?(:message)
           error.message

data/lib/active_agent/generation_provider/ollama_provider.rb

@@ -9,7 +9,56 @@ module ActiveAgent
         @access_token ||= config["api_key"] || config["access_token"] || ENV["OLLAMA_API_KEY"] || ENV["OLLAMA_ACCESS_TOKEN"]
         @model_name = config["model"]
         @host = config["host"] || "http://localhost:11434"
-        @client = OpenAI::Client.new(uri_base: @host, access_token: @access_token, log_errors: true)
+        @api_version = config["api_version"] || "v1"
+        @client = OpenAI::Client.new(uri_base: @host, access_token: @access_token, log_errors: Rails.env.development?, api_version: @api_version)
+      end
+
+      protected
+
+      def format_error_message(error)
+        # Check for various connection-related errors
+        connection_errors = [
+          Errno::ECONNREFUSED,
+          Errno::EADDRNOTAVAIL,
+          Errno::EHOSTUNREACH,
+          Net::OpenTimeout,
+          Net::ReadTimeout,
+          SocketError,
+          Faraday::ConnectionFailed
+        ]
+
+        if connection_errors.any? { |klass| error.is_a?(klass) } ||
+            (error.message&.include?("Failed to open TCP connection") ||
+             error.message&.include?("Connection refused"))
+          "Unable to connect to Ollama at #{@host}. Please ensure Ollama is running on the configured host and port.\n" \
+          "You can start Ollama with: `ollama serve`\n" \
+          "Or update your configuration to point to the correct host."
+        else
+          super
+        end
+      end
+
+      def embeddings_parameters(input: prompt.message.content, model: "nomic-embed-text")
+        {
+          model: @config["embedding_model"] || model,
+          input: input
+        }
+      end
+
+      def embeddings_response(response, request_params = nil)
+        # Ollama can return either format:
+        # 1. OpenAI-compatible: { "data": [{ "embedding": [...] }] }
+        # 2. Native Ollama: { "embedding": [...] }
+        embedding = response.dig("data", 0, "embedding") || response.dig("embedding")
+
+        message = ActiveAgent::ActionPrompt::Message.new(content: embedding, role: "assistant")
+
+        @response = ActiveAgent::GenerationProvider::Response.new(
+          prompt: prompt,
+          message: message,
+          raw_response: response,
+          raw_request: request_params
+        )
       end
     end
   end

data/lib/active_agent/generation_provider/open_ai_provider.rb

@@ -2,7 +2,7 @@ begin
   gem "ruby-openai", ">= 8.1.0"
   require "openai"
 rescue LoadError
-  raise LoadError, "The 'ruby-openai' gem is required for OpenAIProvider. Please add it to your Gemfile and run `bundle install`."
+  raise LoadError, "The 'ruby-openai >= 8.1.0' gem is required for OpenAIProvider. Please add it to your Gemfile and run `bundle install`."
 end
 
 require "active_agent/action_prompt/action"
@@ -31,7 +31,7 @@ module ActiveAgent
           organization_id: @organization_id,
           admin_token: @admin_token,
           log_errors: Rails.env.development?
-          )
+        )
 
         @model_name = config["model"] || "gpt-4o-mini"
       end
@@ -92,10 +92,39 @@ module ActiveAgent
 
       private
 
-      # Now using modules, but we can override build_provider_parameters for OpenAI-specific needs
-      # The prompt_parameters method comes from ParameterBuilder module
-      # The format_tools method comes from ToolManagement module
-      # The provider_messages method comes from MessageFormatting module
+      # Override from ParameterBuilder to add web_search_options for Chat API
+      def build_provider_parameters
+        params = {}
+
+        # Check if we're using a model that supports web_search_options in Chat API
+        if chat_api_web_search_model? && @prompt.options[:web_search]
+          params[:web_search_options] = build_web_search_options(@prompt.options[:web_search])
+        end
+
+        params
+      end
+
+      def chat_api_web_search_model?
+        model = @prompt.options[:model] || @model_name
+        [ "gpt-4o-search-preview", "gpt-4o-mini-search-preview" ].include?(model)
+      end
+
+      def build_web_search_options(web_search_config)
+        options = {}
+
+        if web_search_config.is_a?(Hash)
+          options[:search_context_size] = web_search_config[:search_context_size] if web_search_config[:search_context_size]
+
+          if web_search_config[:user_location]
+            options[:user_location] = {
+              type: "approximate",
+              approximate: web_search_config[:user_location]
+            }
+          end
+        end
+
+        options
+      end
 
       def chat_response(response, request_params = nil)
         return @response if prompt.options[:stream]
@@ -123,7 +152,7 @@ module ActiveAgent
           role: message_json["role"].intern,
           action_requested: message_json["finish_reason"] == "tool_calls",
           raw_actions: message_json["tool_calls"] || [],
-          content_type: prompt.output_schema.present? ? "application/json" : "text/plain",
+          content_type: prompt.output_schema.present? ? "application/json" : "text/plain"
         )
 
         @response = ActiveAgent::GenerationProvider::Response.new(
@@ -141,7 +170,8 @@ module ActiveAgent
           role: message_json["role"].intern,
           action_requested: message_json["finish_reason"] == "tool_calls",
           raw_actions: message_json["tool_calls"] || [],
-          requested_actions: handle_actions(message_json["tool_calls"])
+          requested_actions: handle_actions(message_json["tool_calls"]),
+          content_type: prompt.output_schema.present? ? "application/json" : "text/plain"
         )
       end
 
@@ -161,14 +191,65 @@ module ActiveAgent
       end
 
       def responses_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @prompt.options[:temperature] || @config["temperature"] || 0.7, tools: @prompt.actions, structured_output: @prompt.output_schema)
+        # Build tools array, combining action tools with built-in tools
+        tools_array = build_tools_for_responses(tools)
+
         {
           model: model,
           input: ActiveAgent::GenerationProvider::ResponsesAdapter.new(@prompt).input,
-          tools: tools.presence,
+          tools: tools_array.presence,
           text: structured_output
         }.compact
       end
 
+      def build_tools_for_responses(action_tools)
+        tools = []
+
+        # Start with action tools (user-defined functions) if any
+        tools.concat(action_tools) if action_tools.present?
+
+        # Add built-in tools if specified in options[:tools]
+        if @prompt.options[:tools].present?
+          built_in_tools = @prompt.options[:tools]
+          built_in_tools = [ built_in_tools ] unless built_in_tools.is_a?(Array)
+
+          built_in_tools.each do |tool|
+            next unless tool.is_a?(Hash)
+
+            case tool[:type]
+            when "web_search_preview", "web_search"
+              web_search_tool = { type: "web_search_preview" }
+              web_search_tool[:search_context_size] = tool[:search_context_size] if tool[:search_context_size]
+              web_search_tool[:user_location] = tool[:user_location] if tool[:user_location]
+              tools << web_search_tool
+
+            when "image_generation"
+              image_gen_tool = { type: "image_generation" }
+              image_gen_tool[:size] = tool[:size] if tool[:size]
+              image_gen_tool[:quality] = tool[:quality] if tool[:quality]
+              image_gen_tool[:format] = tool[:format] if tool[:format]
+              image_gen_tool[:compression] = tool[:compression] if tool[:compression]
+              image_gen_tool[:background] = tool[:background] if tool[:background]
+              image_gen_tool[:partial_images] = tool[:partial_images] if tool[:partial_images]
+              tools << image_gen_tool
+
+            when "mcp"
+              mcp_tool = { type: "mcp" }
+              mcp_tool[:server_label] = tool[:server_label] if tool[:server_label]
+              mcp_tool[:server_description] = tool[:server_description] if tool[:server_description]
+              mcp_tool[:server_url] = tool[:server_url] if tool[:server_url]
+              mcp_tool[:connector_id] = tool[:connector_id] if tool[:connector_id]
+              mcp_tool[:authorization] = tool[:authorization] if tool[:authorization]
+              mcp_tool[:require_approval] = tool[:require_approval] if tool[:require_approval]
+              mcp_tool[:allowed_tools] = tool[:allowed_tools] if tool[:allowed_tools]
+              tools << mcp_tool
+            end
+          end
+        end
+
+        tools
+      end
+
       def embeddings_parameters(input: prompt.message.content, model: "text-embedding-3-large")
         {
           model: model,

data/lib/active_agent/railtie/schema_generator_extension.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_agent/schema_generator"
+
+module ActiveAgent
+  class SchemaGeneratorRailtie < Rails::Railtie
+    initializer "active_agent.schema_generator" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Base.include ActiveAgent::SchemaGenerator
+      end
+
+      ActiveSupport.on_load(:active_model) do
+        if defined?(ActiveModel::Model)
+          ActiveModel::Model.include ActiveAgent::SchemaGenerator
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/railtie.rb

@@ -5,6 +5,7 @@ require "active_agent"
 # require "active_agent/engine"
 require "rails"
 require "abstract_controller/railties/routes_helpers"
+require "active_agent/railtie/schema_generator_extension"
 
 module ActiveAgent
   class Railtie < Rails::Railtie # :nodoc:

data/lib/active_agent/schema_generator.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module SchemaGenerator
+    extend ActiveSupport::Concern
+
+    included do
+      if defined?(ActiveRecord::Base) && self < ActiveRecord::Base
+        extend ActiveRecordClassMethods
+      elsif defined?(ActiveModel::Model) && self.included_modules.include?(ActiveModel::Model)
+        extend ActiveModelClassMethods
+      else
+        # Fallback for any class that includes this module
+        extend ActiveModelClassMethods
+      end
+    end
+
+    module ActiveRecordClassMethods
+      def to_json_schema(options = {})
+        ActiveAgent::SchemaGenerator::Builder.json_schema_from_model(self, options)
+      end
+    end
+
+    module ActiveModelClassMethods
+      def to_json_schema(options = {})
+        ActiveAgent::SchemaGenerator::Builder.json_schema_from_model(self, options)
+      end
+    end
+
+    class Builder
+      def self.json_schema_from_model(model_class, options = {})
+        schema = {
+          type: "object",
+          properties: {},
+          required: [],
+          additionalProperties: options.fetch(:additional_properties, false)
+        }
+
+        if defined?(ActiveRecord::Base) && model_class < ActiveRecord::Base
+          build_activerecord_schema(model_class, schema, options)
+        elsif defined?(ActiveModel::Model) && model_class.include?(ActiveModel::Model)
+          build_activemodel_schema(model_class, schema, options)
+        else
+          raise ArgumentError, "Model must be an ActiveRecord or ActiveModel class"
+        end
+
+        if options[:strict]
+          # OpenAI strict mode requires all properties to be in the required array
+          # So we add all properties to required if strict mode is enabled
+          schema[:required] = schema[:properties].keys.map(&:to_s).sort
+
+          {
+            name: options[:name] || model_class.name.underscore,
+            schema: schema,
+            strict: true
+          }
+        else
+          schema
+        end
+      end
+
+      class << self
+        private
+
+        def build_activerecord_schema(model_class, schema, options)
+          model_class.columns.each do |column|
+            next if options[:exclude]&.include?(column.name.to_sym)
+            next if column.name == "id" && !options[:include_id]
+
+            property = build_property_from_column(column)
+            schema[:properties][column.name] = property
+
+            if !column.null && column.name != "id"
+              schema[:required] << column.name
+            end
+          end
+
+          if model_class.reflect_on_all_associations.any?
+            add_associations_to_schema(model_class, schema, options)
+          end
+
+          if model_class.respond_to?(:validators)
+            add_validations_to_schema(model_class, schema, options)
+          end
+      end
+
+        def build_activemodel_schema(model_class, schema, options)
+        if model_class.respond_to?(:attribute_types)
+          model_class.attribute_types.each do |name, type|
+            next if options[:exclude]&.include?(name.to_sym)
+
+            property = build_property_from_type(type)
+            schema[:properties][name] = property
+          end
+        end
+
+        if model_class.respond_to?(:validators)
+          add_validations_to_schema(model_class, schema, options)
+        end
+      end
+
+        def build_property_from_column(column)
+        property = {
+          type: map_sql_type_to_json_type(column.type),
+          description: "#{column.name.humanize} field"
+        }
+
+        case column.type
+        when :string, :text
+          if column.limit
+            property[:maxLength] = column.limit
+          end
+        when :integer, :bigint
+          property[:type] = "integer"
+        when :decimal, :float
+          property[:type] = "number"
+        when :boolean
+          property[:type] = "boolean"
+        when :date, :datetime, :timestamp
+          property[:type] = "string"
+          property[:format] = (column.type == :date) ? "date" : "date-time"
+        when :json, :jsonb
+          property[:type] = "object"
+        else
+          property[:type] = "string"
+        end
+
+        if column.default
+          property[:default] = column.default
+        end
+
+        property
+      end
+
+        def build_property_from_type(type)
+        property = { type: "string" }
+
+        case type
+        when ActiveModel::Type::String
+          property[:type] = "string"
+        when ActiveModel::Type::Integer
+          property[:type] = "integer"
+        when ActiveModel::Type::Float, ActiveModel::Type::Decimal
+          property[:type] = "number"
+        when ActiveModel::Type::Boolean
+          property[:type] = "boolean"
+        when ActiveModel::Type::Date
+          property[:type] = "string"
+          property[:format] = "date"
+        when ActiveModel::Type::DateTime, ActiveModel::Type::Time
+          property[:type] = "string"
+          property[:format] = "date-time"
+        else
+          property[:type] = "string"
+        end
+
+        property
+      end
+
+        def map_sql_type_to_json_type(sql_type)
+        case sql_type
+        when :string, :text
+          "string"
+        when :integer, :bigint
+          "integer"
+        when :decimal, :float
+          "number"
+        when :boolean
+          "boolean"
+        when :json, :jsonb
+          "object"
+        when :array
+          "array"
+        else
+          "string"
+        end
+      end
+
+        def add_associations_to_schema(model_class, schema, options)
+        return unless options[:include_associations]
+
+        schema[:$defs] ||= {}
+
+        model_class.reflect_on_all_associations.each do |association|
+          next if options[:exclude_associations]&.include?(association.name)
+
+          case association.macro
+          when :has_many, :has_and_belongs_to_many
+            schema[:properties][association.name.to_s] = {
+              type: "array",
+              items: { "$ref": "#/$defs/#{association.name.to_s.singularize}" }
+            }
+            if options[:nested_associations]
+              nested_schema = json_schema_from_model(
+                association.klass,
+                options.merge(include_associations: false)
+              )
+              schema[:$defs][association.name.to_s.singularize] = nested_schema
+            end
+          when :has_one, :belongs_to
+            schema[:properties][association.name.to_s] = {
+              "$ref": "#/$defs/#{association.name}"
+            }
+            if options[:nested_associations]
+              nested_schema = json_schema_from_model(
+                association.klass,
+                options.merge(include_associations: false)
+              )
+              schema[:$defs][association.name.to_s] = nested_schema
+            end
+          end
+        end
+      end
+
+        def add_validations_to_schema(model_class, schema, options)
+        model_class.validators.each do |validator|
+          validator.attributes.each do |attribute|
+            next unless schema[:properties][attribute.to_s]
+
+            case validator
+            when ActiveModel::Validations::PresenceValidator
+              schema[:required] << attribute.to_s unless schema[:required].include?(attribute.to_s)
+            when ActiveModel::Validations::LengthValidator
+              if validator.options[:minimum]
+                schema[:properties][attribute.to_s][:minLength] = validator.options[:minimum]
+              end
+              if validator.options[:maximum]
+                schema[:properties][attribute.to_s][:maxLength] = validator.options[:maximum]
+              end
+            when ActiveModel::Validations::NumericalityValidator
+              if validator.options[:greater_than]
+                schema[:properties][attribute.to_s][:exclusiveMinimum] = validator.options[:greater_than]
+              end
+              if validator.options[:less_than]
+                schema[:properties][attribute.to_s][:exclusiveMaximum] = validator.options[:less_than]
+              end
+              if validator.options[:greater_than_or_equal_to]
+                schema[:properties][attribute.to_s][:minimum] = validator.options[:greater_than_or_equal_to]
+              end
+              if validator.options[:less_than_or_equal_to]
+                schema[:properties][attribute.to_s][:maximum] = validator.options[:less_than_or_equal_to]
+              end
+            when ActiveModel::Validations::InclusionValidator
+              if validator.options[:in]
+                schema[:properties][attribute.to_s][:enum] = validator.options[:in]
+              end
+            when ActiveModel::Validations::FormatValidator
+              if validator.options[:with] == URI::MailTo::EMAIL_REGEXP
+                schema[:properties][attribute.to_s][:format] = "email"
+              elsif validator.options[:with]
+                schema[:properties][attribute.to_s][:pattern] = validator.options[:with].source
+              end
+            end
+          end
+        end
+      end
+      end
+    end
+
+    def generate_schema_view(model_class, options = {})
+      schema = ActiveAgent::SchemaGenerator::Builder.json_schema_from_model(model_class, options)
+      schema.to_json
+    end
+  end
+end

data/lib/active_agent/version.rb

@@ -1,3 +1,3 @@
 module ActiveAgent
-  VERSION = "0.6.0rc4"
+  VERSION = "0.6.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeagent
 version: !ruby/object:Gem::Version
-  version: 0.6.0rc4
+  version: 0.6.1
 platform: ruby
 authors:
 - Justin Bowen
@@ -249,6 +249,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: cuprite
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.40'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.40'
 description: The only agent-oriented AI framework designed for Rails, where Agents
   are Controllers. Build AI features with less complexity using the MVC conventions
   you love.
@@ -295,8 +323,10 @@ files:
 - lib/active_agent/prompt_helper.rb
 - lib/active_agent/queued_generation.rb
 - lib/active_agent/railtie.rb
+- lib/active_agent/railtie/schema_generator_extension.rb
 - lib/active_agent/rescuable.rb
 - lib/active_agent/sanitizers.rb
+- lib/active_agent/schema_generator.rb
 - lib/active_agent/service.rb
 - lib/active_agent/streaming.rb
 - lib/active_agent/test_case.rb