activeagent 0.4.2 → 0.5.0rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47bdf9e37e7297013da9b708a3dde24829cff913ef1ec74abc273768af85f4b9
-  data.tar.gz: ad71eb99a02c3d527b9c43b9728be6f861a4f7b230eb3258709135d6268b88ce
+  metadata.gz: 84fb3a9276bfde64ad37b2c77498bb4516a7ba73902fd2dde9e145582b651681
+  data.tar.gz: cc8b182729b625c8d0fc6d34addb082602874fc22452e48a38bb9780145d956b
 SHA512:
-  metadata.gz: b796e122648f92d27f8bb7b8ae2f7933cddc47bf7d4af682086375b6b775b54d50e8d05d94e5e70bb5dbd28b15cd17a24639d2ecde1d69dd2ef57a6bf1f29c23
-  data.tar.gz: 58e8fddc983ca61e142e7710ff6c7315bff8215ecc007dee903ab499602ba323958fe84ec756f7932290cab2dcac214664e760d37588aada9368aacbe7492720
+  metadata.gz: 040e898a392c9da21a304c966f947db67698431f66c2972d27e1572a6763adf3368bd6a2456ee3826b2a5055df521c6ab2503566357178bea77c55aa0f9d18a6
+  data.tar.gz: 5d331eab9c61a1a1a008f71469b7d1714e0ddcbe2ed60f5a140390ab009d06839c4ef485808fb125518ab5b02fe91ecb5db22b656296331ec883a080fffed490

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Active Agents AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,12 @@
+![Active Agent Logo](https://framerusercontent.com/images/oEx786EYW2ZVL4Xf9hparOVLjHI.png)
+> *Build AI in Rails*
+>
+> *Now Agents are Controllers*
+>
+> *Makes code [TonsOfFun](https://tonsoffun.github.io)!*
+
+# Active Agent
+Active Agent provides that missing AI layer in the Rails framework, offering a structured approach to building AI-powered applications through Agent Oriented Programming. **Now Agents are Controllers!** Designing applications using agents allows developers to create modular, reusable components that can be easily integrated into existing systems. This approach promotes code reusability, maintainability, and scalability, making it easier to build complex AI-driven applications with the Object Oriented Ruby code you already use today.
+
+## Documentation
+[docs.activeagents.ai](https://docs.activeagents.ai) - The official documentation site for Active Agent.

data/lib/active_agent/action_prompt/base.rb

@@ -9,7 +9,6 @@ module ActiveAgent
   module ActionPrompt
     class Base < AbstractController::Base
       include Callbacks
-      include GenerationMethods
       include GenerationProvider
       include QueuedGeneration
       include Rescuable
@@ -105,9 +104,16 @@ module ActiveAgent
         # Define how the agent should generate content
         def generate_with(provider, **options)
           self.generation_provider = provider
-          self.options = (options || {}).merge(options)
+
+          if options.has_key?(:instructions) || (self.options || {}).empty?
+            # Either instructions explicitly provided, or no inherited options exist
+            self.options = (self.options || {}).merge(options)
+          else
+            # Don't inherit instructions from parent if not explicitly set
+            inherited_options = (self.options || {}).except(:instructions)
+            self.options = inherited_options.merge(options)
+          end
           self.options[:stream] = new.agent_stream if self.options[:stream]
-          generation_provider.config.merge!(self.options)
         end
 
         def stream_with(&stream)
@@ -239,9 +245,7 @@ module ActiveAgent
       def initialize
         super
         @_prompt_was_called = false
-        @_context = ActiveAgent::ActionPrompt::Prompt.new(
-          instructions: prepare_instructions(options[:instructions]), options: options
-        )
+        @_context = ActiveAgent::ActionPrompt::Prompt.new(options: self.class.options || {})
       end
 
       def process(method_name, *args) # :nodoc:
@@ -296,24 +300,26 @@ module ActiveAgent
       def prompt(headers = {}, &block)
         return context if @_prompt_was_called && headers.blank? && !block
 
-        context.instructions = prepare_instructions(headers[:instructions]) if headers.has_key?(:instructions)
-        context.options.merge!(options)
+        # Apply option hierarchy: prompt options > agent options > config options
+        merged_options = merge_options(headers)
+        raw_instructions = headers.has_key?(:instructions) ? headers[:instructions] : context.options[:instructions]
+
+        context.instructions = prepare_instructions(raw_instructions)
+
+        context.options.merge!(merged_options)
+
         content_type = headers[:content_type]
+
         headers = apply_defaults(headers)
         context.messages = headers[:messages] || []
         context.context_id = headers[:context_id]
         context.params = params
 
-        context.charset = charset = headers[:charset]
+        context.output_schema = load_schema(headers[:output_schema], set_prefixes(headers[:output_schema], lookup_context.prefixes))
 
-        if headers[:message].present? && headers[:message].is_a?(ActiveAgent::ActionPrompt::Message)
-          headers[:body] = headers[:message].content
-          headers[:role] = headers[:message].role
-        elsif headers[:message].present? && headers[:message].is_a?(String)
-          headers[:body] = headers[:message]
-          headers[:role] = :user
-        end
+        context.charset = charset = headers[:charset]
 
+        headers = prepare_message(headers)
         # wrap_generation_behavior!(headers[:generation_method], headers[:generation_method_options])
         # assign_headers_to_context(context, headers)
         responses = collect_responses(headers, &block)
@@ -323,33 +329,108 @@ module ActiveAgent
         create_parts_from_responses(context, responses)
 
         context.content_type = set_content_type(context, content_type, headers[:content_type])
+
         context.charset = charset
         context.actions = headers[:actions] || action_schemas
 
-        if (action_methods - ActiveAgent::Base.descendants.first.action_methods).include? action_name
-          context.actions = (action_methods - [ action_name ])
-        end
-
         context
       end
 
       def action_methods
-        super - ActiveAgent::Base.public_instance_methods(false).map(&:to_s)
+        super - ActiveAgent::Base.public_instance_methods(false).map(&:to_s) - [ action_name ]
       end
 
       def action_schemas
+        prefixes = set_prefixes(action_name, lookup_context.prefixes)
+
         action_methods.map do |action|
-          JSON.parse render_to_string(locals: { action_name: action }, action: action, formats: :json)
+          load_schema(action, prefixes)
         end.compact
       end
 
       private
+      def prepare_message(headers)
+        if headers[:message].present? && headers[:message].is_a?(ActiveAgent::ActionPrompt::Message)
+          headers[:body] = headers[:message].content
+          headers[:role] = headers[:message].role
+        elsif headers[:message].present? && headers[:message].is_a?(String)
+          headers[:body] = headers[:message]
+          headers[:role] = :user
+        end
+        load_input_data(headers)
+
+        headers
+      end
+
+      def load_input_data(headers)
+        if headers[:image_data].present?
+          headers[:body] = [
+            ActiveAgent::ActionPrompt::Message.new(content: headers[:image_data], content_type: "image_data"),
+            ActiveAgent::ActionPrompt::Message.new(content: headers[:body], content_type: "input_text")
+          ]
+        elsif headers[:file_data].present?
+          headers[:body] = [
+            ActiveAgent::ActionPrompt::Message.new(content: headers[:file_data], metadata: { filename: "resume.pdf" }, content_type: "file_data"),
+            ActiveAgent::ActionPrompt::Message.new(content: headers[:body], content_type: "input_text")
+          ]
+        end
+
+        headers
+      end
+
+      def set_prefixes(action, prefixes)
+        prefixes = lookup_context.prefixes | [ self.class.agent_name ]
+      end
+
+      def load_schema(action_name, prefixes)
+        return unless lookup_context.template_exists?(action_name, prefixes, false, formats: [ :json ])
+
+        JSON.parse render_to_string(locals: { action_name: action_name }, action: action_name, formats: :json)
+      end
 
-      def set_content_type(m, user_content_type, class_default) # :doc:
+      def merge_options(prompt_options)
+        config_options = generation_provider&.config || {}
+        agent_options = (self.class.options || {}).deep_dup  # Defensive copy to prevent mutation
+
+        parent_options = self.class.superclass.respond_to?(:options) ? (self.class.superclass.options || {}) : {}
+
+        # Extract runtime options from prompt_options (exclude instructions as it has special template logic)
+        runtime_options = prompt_options.slice(
+          :model, :temperature, :max_tokens, :stream, :top_p, :frequency_penalty,
+          :presence_penalty, :response_format, :seed, :stop, :tools_choice, :user
+        )
+
+        # Handle explicit options parameter
+        explicit_options = prompt_options[:options] || {}
+
+        # Merge with proper precedence: config < agent < explicit_options
+        # Don't include instructions in automatic merging as it has special template fallback logic
+        config_options_filtered = config_options.except(:instructions)
+        agent_options_filtered = agent_options.except(:instructions)
+        explicit_options_filtered = explicit_options.except(:instructions)
+
+        merged = config_options_filtered.merge(agent_options_filtered).merge(explicit_options_filtered)
+
+        # Only merge runtime options that are actually present (not nil)
+        runtime_options.each do |key, value|
+          next if value.nil?
+          # Special handling for stream option: preserve agent_stream proc if it exists
+          if key == :stream && agent_options[:stream].is_a?(Proc) && !value.is_a?(Proc)
+            next
+          end
+          merged[key] = value
+        end
+
+        merged
+      end
+
+      def set_content_type(prompt_context, user_content_type, class_default) # :doc:
         if user_content_type.present?
           user_content_type
-        else
-          context.content_type || class_default
+        elsif context.multimodal?
+          "multipart/mixed"
+        elsif prompt_context.body.is_a?(Array)
+          prompt_context.content_type || class_default
         end
       end
 
@@ -435,10 +516,7 @@ module ActiveAgent
 
       def create_parts_from_responses(context, responses)
         if responses.size > 1
-          # prompt_container = ActiveAgent::ActionPrompt::Prompt.new
-          # prompt_container.content_type = "multipart/alternative"
           responses.each { |r| insert_part(context, r, context.charset) }
-          # context.add_part(prompt_container)
         else
           responses.each { |r| insert_part(context, r, context.charset) }
         end

data/lib/active_agent/action_prompt/message.rb

@@ -18,12 +18,13 @@ 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
+      attr_accessor :action_id, :action_name, :raw_actions, :generation_id, :content, :role, :action_requested, :requested_actions, :content_type, :charset, :metadata
 
       def initialize(attributes = {})
         @action_id = attributes[:action_id]
         @action_name = attributes[:action_name]
         @generation_id = attributes[:generation_id]
+        @metadata = attributes[:metadata] || {}
         @charset = attributes[:charset] || "UTF-8"
         @content = attributes[:content] || ""
         @content_type = attributes[:content_type] || "text/plain"
@@ -58,6 +59,30 @@ module ActiveAgent
         @agent_class.embed(@content)
       end
 
+      def inspect
+        truncated_content = if @content.is_a?(String) && @content.length > 256
+          @content[0, 256] + "..."
+        elsif @content.is_a?(Array)
+          @content.map do |item|
+            if item.is_a?(String) && item.length > 256
+              item[0, 256] + "..."
+            else
+              item
+            end
+          end
+        else
+          @content
+        end
+
+        "#<#{self.class}:0x#{object_id.to_s(16)}\n" +
+        "    @action_id=#{@action_id.inspect},\n" +
+        "    @action_name=#{@action_name.inspect},\n" +
+        "    @action_requested=#{@action_requested.inspect},\n" +
+        "    @charset=#{@charset.inspect},\n" +
+        "    @content=#{truncated_content.inspect},\n" +
+        "    @role=#{@role.inspect}>"
+      end
+
       private
 
       def validate_role

data/lib/active_agent/action_prompt/prompt.rb

@@ -4,10 +4,11 @@ module ActiveAgent
   module ActionPrompt
     class Prompt
       attr_reader :messages, :instructions
-      attr_accessor :actions, :body, :content_type, :context_id, :message, :options, :mime_version, :charset, :context, :parts, :params, :action_choice, :agent_class
+      attr_accessor :actions, :body, :content_type, :context_id, :message, :options, :mime_version, :charset, :context, :parts, :params, :action_choice, :agent_class, :output_schema
 
       def initialize(attributes = {})
         @options = attributes.fetch(:options, {})
+        @multimodal = attributes.fetch(:multimodal, false)
         @agent_class = attributes.fetch(:agent_class, ApplicationAgent)
         @actions = attributes.fetch(:actions, [])
         @action_choice = attributes.fetch(:action_choice, "")
@@ -23,17 +24,24 @@ module ActiveAgent
         @context_id = attributes.fetch(:context_id, nil)
         @headers = attributes.fetch(:headers, {})
         @parts = attributes.fetch(:parts, [])
+        @output_schema = attributes.fetch(:output_schema, nil)
         @messages = Message.from_messages(@messages)
         set_message if attributes[:message].is_a?(String) || @body.is_a?(String) && @message&.content
         set_messages if @instructions.present?
       end
 
+      def multimodal?
+        @multimodal ||= @message&.content.is_a?(Array) || @messages.any? { |m| m.content.is_a?(Array) }
+      end
+
       def messages=(messages)
         @messages = messages
         set_messages
       end
 
       def instructions=(instructions)
+        return if instructions.blank?
+
         @instructions = instructions
         if @messages[0].present? && @messages[0].role == :system
           @messages[0] = instructions_message
@@ -72,6 +80,20 @@ module ActiveAgent
         }
       end
 
+      def inspect
+        "#<#{self.class}:0x#{object_id.to_s(16)}\n" +
+          "  @options=#{@options.inspect.gsub(Rails.application.credentials.dig(:openai, :api_key), '<OPENAI_API_KEY>')}\n" +
+          "  @actions=#{@actions.inspect}\n" +
+          "  @action_choice=#{@action_choice.inspect}\n" +
+          "  @instructions=#{@instructions.inspect}\n" +
+          "  @message=#{@message.inspect}\n" +
+          "  @output_schema=#{@output_schema}\n" +
+          "  @headers=#{@headers.inspect}\n" +
+          "  @context=#{@context.inspect}\n" +
+          "  @messages=#{@messages.inspect}\n" +
+          ">"
+      end
+
       def headers(headers = {})
         @headers.merge!(headers)
       end
@@ -84,6 +106,9 @@ module ActiveAgent
 
       def set_messages
         @messages = [ instructions_message ] + @messages
+        # if @message.nil? || @message.content.blank?
+        #   @message = @messages.last
+        # end
       end
 
       def set_message

data/lib/active_agent/action_prompt.rb

@@ -15,113 +15,5 @@ module ActiveAgent
     autoload :Base
 
     extend ActiveSupport::Concern
-
-    included do
-      include AbstractController::Rendering
-      include AbstractController::Layouts
-      include AbstractController::Helpers
-      include AbstractController::Translation
-      include AbstractController::AssetPaths
-      include AbstractController::Callbacks
-      include AbstractController::Caching
-
-      include ActionView::Layouts
-
-      helper ActiveAgent::PromptHelper
-      # class_attribute :default_params, default: {
-      #   content_type: "text/plain",
-      #   parts_order: ["text/plain", "text/html", "application/json"]
-      # }.freeze
-    end
-
-    # # def self.prompt(headers = {}, &)
-    # #   new.prompt(headers, &)
-    # # end
-
-    # def prompt(headers = {}, &block)
-    #   return @_message if @_prompt_was_called && headers.blank? && !block
-
-    #   headers = apply_defaults(headers)
-
-    #   @_message = ActiveAgent::ActionPrompt::Prompt.new
-
-    #   assign_headers_to_message(@_message, headers)
-
-    #   responses = collect_responses(headers, &block)
-
-    #   @_prompt_was_called = true
-
-    #   create_parts_from_responses(@_message, responses)
-
-    #   @_message
-    # end
-
-    private
-
-    def apply_defaults(headers)
-      headers.reverse_merge(self.class.default_params)
-    end
-
-    def assign_headers_to_message(message, headers)
-      assignable = headers.except(:parts_order, :content_type, :body, :template_name, :template_path)
-      assignable.each { |k, v| message.send(:"#{k}=", v) }
-    end
-
-    def collect_responses(headers, &block)
-      if block
-        collect_responses_from_block(headers, &block)
-      elsif headers[:body]
-        collect_responses_from_text(headers)
-      else
-        collect_responses_from_templates(headers)
-      end
-    end
-
-    def collect_responses_from_block(headers, &block)
-      templates_name = headers[:template_name] || action_name
-      collector = ActiveAgent::ActionPrompt::Collector.new(lookup_context) { render(templates_name) }
-      yield(collector)
-      collector.responses
-    end
-
-    def collect_responses_from_text(headers)
-      [ {
-        body: headers.delete(:body),
-        content_type: headers[:content_type] || "text/plain"
-      } ]
-    end
-
-    def collect_responses_from_templates(headers)
-      templates_path = headers[:template_path] || self.class.name.sub(/Agent$/, "").underscore
-      templates_name = headers[:template_name] || action_name
-      each_template(Array(templates_path), templates_name).map do |template|
-        format = template.format || formats.first
-        {
-          body: render(template: template, formats: [ format ]),
-          content_type: Mime[format].to_s
-        }
-      end
-    end
-
-    def each_template(paths, name, &)
-      templates = lookup_context.find_all(name, paths)
-      if templates.empty?
-        raise ActionView::MissingTemplate.new(paths, name, paths, false, "prompt")
-      else
-        templates.uniq(&:format).each(&)
-      end
-    end
-
-    def create_parts_from_responses(message, responses)
-      responses.each do |response|
-        message.add_part(response[:body], content_type: response[:content_type])
-      end
-    end
-
-    class TestAgent
-      class << self
-        attr_accessor :generations
-      end
-    end
   end
 end

data/lib/active_agent/base.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_agent/action_prompt"
 require "active_agent/prompt_helper"
 require "active_agent/action_prompt/base"
 
@@ -29,8 +30,16 @@ module ActiveAgent
     # ActiveAgent::Base is designed to be extended by specific agent implementations.
     # It provides a common set of agent actions for self-contained agents that can determine their own actions using all available actions.
     # Base actions include: prompt_context, continue, reasoning, reiterate, and conclude
-    def prompt_context
-      prompt(stream: params[:stream], messages: params[:messages], message: params[:message], context_id: params[:context_id])
+    def prompt_context(additional_options = {})
+      prompt(
+        {
+          stream: params[:stream],
+          messages: params[:messages],
+          message: params[:message],
+          context_id: params[:context_id],
+          options: params[:options]
+        }.merge(additional_options)
+      )
     end
   end
 end

data/lib/active_agent/generation_provider/anthropic_provider.rb

@@ -20,7 +20,8 @@ module ActiveAgent
 
         chat_prompt(parameters: prompt_parameters)
       rescue => e
-        raise GenerationProviderError, e.message
+        error_message = e.respond_to?(:message) ? e.message : e.to_s
+        raise GenerationProviderError, error_message
       end
 
       def chat_prompt(parameters: prompt_parameters)
@@ -44,12 +45,12 @@ module ActiveAgent
         end
       end
 
-      def prompt_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @config["temperature"] || 0.7, tools: @prompt.actions)
+      def prompt_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @prompt.options[:temperature] || @config["temperature"] || 0.7, tools: @prompt.actions)
         params = {
           model: model,
           messages: provider_messages(messages),
           temperature: temperature,
-          max_tokens: 4096
+          max_tokens: @prompt.options[:max_tokens] || @config["max_tokens"] || 4096
         }
 
         if tools&.present?

data/lib/active_agent/generation_provider/base_adapter.rb

@@ -0,0 +1,19 @@
+module ActiveAgent
+  module GenerationProvider
+    class BaseAdapter
+      attr_reader :prompt
+
+      def initialize(prompt)
+        @prompt = prompt
+      end
+
+      def input
+        raise NotImplementedError, "Subclasses must implement the 'input' method"
+      end
+
+      def response
+        raise NotImplementedError, "Subclasses must implement the 'response' method"
+      end
+    end
+  end
+end

data/lib/active_agent/generation_provider/open_ai_provider.rb

@@ -1,7 +1,14 @@
-require "openai"
+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`."
+end
+
 require "active_agent/action_prompt/action"
 require_relative "base"
 require_relative "response"
+require_relative "responses_adapter"
 
 module ActiveAgent
   module GenerationProvider
@@ -21,9 +28,14 @@ module ActiveAgent
       def generate(prompt)
         @prompt = prompt
 
-        chat_prompt(parameters: prompt_parameters)
+        if @prompt.multimodal? || @prompt.content_type == "multipart/mixed"
+          responses_prompt(parameters: responses_parameters)
+        else
+          chat_prompt(parameters: prompt_parameters)
+        end
       rescue => e
-        raise GenerationProviderError, e.message
+        error_message = e.respond_to?(:message) ? e.message : e.to_s
+        raise GenerationProviderError, error_message
       end
 
       def embed(prompt)
@@ -31,7 +43,8 @@ module ActiveAgent
 
         embeddings_prompt(parameters: embeddings_parameters)
       rescue => e
-        raise GenerationProviderError, e.message
+        error_message = e.respond_to?(:message) ? e.message : e.to_s
+        raise GenerationProviderError, error_message
       end
 
       private
@@ -63,13 +76,14 @@ module ActiveAgent
         end
       end
 
-      def prompt_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @config["temperature"] || 0.7, tools: @prompt.actions)
+      def prompt_parameters(model: @prompt.options[:model] || @model_name, messages: @prompt.messages, temperature: @prompt.options[:temperature] || @config["temperature"] || 0.7, tools: @prompt.actions)
         {
           model: model,
           messages: provider_messages(messages),
           temperature: temperature,
+          max_tokens: @prompt.options[:max_tokens] || @config["max_tokens"],
           tools: tools.presence
-        }
+        }.compact
       end
 
       def provider_messages(messages)
@@ -104,6 +118,22 @@ module ActiveAgent
         @response = ActiveAgent::GenerationProvider::Response.new(prompt: prompt, message: message, raw_response: response)
       end
 
+      def responses_response(response)
+        message_json = response.dig("output", 0)
+        message_json["id"] = response.dig("id") if message_json["id"].blank?
+
+        message = ActiveAgent::ActionPrompt::Message.new(
+          generate_id: message_json["id"],
+          content: message_json["content"].first["text"],
+          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",
+        )
+
+        @response = ActiveAgent::GenerationProvider::Response.new(prompt: prompt, message: message, raw_response: response)
+      end
+
       def handle_message(message_json)
         ActiveAgent::ActionPrompt::Message.new(
           generation_id: message_json["id"],
@@ -135,6 +165,20 @@ module ActiveAgent
         chat_response(@client.chat(parameters: parameters))
       end
 
+      def responses_prompt(parameters: responses_parameters)
+        # parameters[:stream] = provider_stream if prompt.options[:stream] || config["stream"]
+        responses_response(@client.responses.create(parameters: parameters))
+      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)
+        {
+          model: model,
+          input: ActiveAgent::GenerationProvider::ResponsesAdapter.new(@prompt).input,
+          tools: tools.presence,
+          text: structured_output
+        }.compact
+      end
+
       def embeddings_parameters(input: prompt.message.content, model: "text-embedding-3-large")
         {
           model: model,

data/lib/active_agent/generation_provider/responses_adapter.rb

@@ -0,0 +1,44 @@
+require_relative "base_adapter"
+
+module ActiveAgent
+  module GenerationProvider
+    class ResponsesAdapter < BaseAdapter
+      def initialize(prompt)
+        super(prompt)
+        @prompt = prompt
+      end
+
+      def input
+          messages.map do |message|
+          if message.content.is_a?(Array)
+            {
+              role: message.role,
+              content: message.content.map do |content_part|
+                if content_part.is_a?(String)
+                  { type: "input_text", text: content_part }
+                elsif content_part.is_a?(ActiveAgent::ActionPrompt::Message) && content_part.content_type == "input_text"
+                  { type: "input_text", text: content_part.content }
+                elsif content_part.is_a?(ActiveAgent::ActionPrompt::Message) && content_part.content_type == "image_data"
+                  { type: "input_image", image_url: content_part.content }
+                elsif content_part.is_a?(ActiveAgent::ActionPrompt::Message) && content_part.content_type == "file_data"
+                  { type: "input_file", filename: content_part.metadata[:filename], file_data: content_part.content }
+                else
+                  raise ArgumentError, "Unsupported content type in message"
+                end
+              end.compact
+            }
+          else
+            {
+              role: message.role,
+              content: message.content
+            }
+          end
+        end.compact
+      end
+
+      def messages
+        prompt.messages
+      end
+    end
+  end
+end

data/lib/active_agent/generation_provider.rb

@@ -23,8 +23,6 @@ module ActiveAgent
       def configure_provider(config)
         require "active_agent/generation_provider/#{config["service"].underscore}_provider"
         ActiveAgent::GenerationProvider.const_get("#{config["service"].camelize}Provider").new(config)
-      rescue LoadError
-        raise "Missing generation provider configuration for #{config["service"].inspect}"
       end
 
       def generation_provider

data/lib/active_agent/parameterized.rb

@@ -13,7 +13,15 @@ module ActiveAgent
     end
 
     module ClassMethods
-      def with(params)
+      def with(params = {})
+        # Separate runtime options from regular params
+        runtime_options = params.extract!(:model, :temperature, :max_tokens, :stream, :top_p,
+                                          :frequency_penalty, :presence_penalty, :response_format,
+                                          :seed, :stop, :tools_choice, :user)
+
+        # Pass runtime options as :options parameter
+        params[:options] = runtime_options if runtime_options.any?
+
         ActiveAgent::Parameterized::Agent.new(self, params)
       end
     end

data/lib/active_agent/version.rb

@@ -1,3 +1,3 @@
 module ActiveAgent
-  VERSION = "0.4.2"
+  VERSION = "0.5.0rc1"
 end

data/lib/active_agent.rb

@@ -34,6 +34,11 @@ module ActiveAgent
   class << self
     attr_accessor :config
 
+    def filter_credential_keys(example)
+      example.gsub(Rails.application.credentials.dig(:openai, :api_key), "<OPENAI_API_KEY>")
+        .gsub(Rails.application.credentials.dig(:open_router, :api_key), "<OPEN_ROUTER_API_KEY>")
+    end
+
     def eager_load!
       super
 

data/lib/generators/erb/install_generator.rb

@@ -8,7 +8,6 @@ module Erb # :nodoc:
       source_root File.expand_path("templates", __dir__)
 
       def create_agent_layouts
-        template "layout.html.erb.tt", "app/views/layouts/agent.html.erb"
         template "layout.text.erb.tt", "app/views/layouts/agent.text.erb"
         template "layout.json.erb.tt", "app/views/layouts/agent.json.erb"
       end

data/lib/generators/test_unit/install_generator.rb

@@ -4,7 +4,7 @@ require "rails/generators/test_unit"
 
 module TestUnit # :nodoc:
   module Generators # :nodoc:
-    class InstallGenerator < Base # :nodoc:
+    class InstallGenerator <  ::Rails::Generators::Base # :nodoc:
       # TestUnit install generator for ActiveAgent
       # This can be used to create additional test-specific files during installation
       # Currently no additional files are needed for TestUnit setup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeagent
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0rc1
 platform: ruby
 authors:
 - Justin Bowen
@@ -110,27 +110,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '9.0'
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: jbuilder
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '9.0'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '9.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: jbuilder
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -152,6 +146,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- LICENSE
+- README.md
 - lib/active_agent.rb
 - lib/active_agent/action_prompt.rb
 - lib/active_agent/action_prompt/action.rb
@@ -164,14 +160,15 @@ files:
 - lib/active_agent/deprecator.rb
 - lib/active_agent/generation.rb
 - lib/active_agent/generation_job.rb
-- lib/active_agent/generation_methods.rb
 - lib/active_agent/generation_provider.rb
 - lib/active_agent/generation_provider/anthropic_provider.rb
 - lib/active_agent/generation_provider/base.rb
+- lib/active_agent/generation_provider/base_adapter.rb
 - lib/active_agent/generation_provider/ollama_provider.rb
 - lib/active_agent/generation_provider/open_ai_provider.rb
 - lib/active_agent/generation_provider/open_router_provider.rb
 - lib/active_agent/generation_provider/response.rb
+- lib/active_agent/generation_provider/responses_adapter.rb
 - lib/active_agent/inline_preview_interceptor.rb
 - lib/active_agent/log_subscriber.rb
 - lib/active_agent/parameterized.rb
@@ -227,7 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.0
 specification_version: 4
 summary: Rails AI Agents Framework
 test_files: []

data/lib/active_agent/generation_methods.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "tmpdir"
-require_relative "action_prompt"
-
-module ActiveAgent
-  # = Active Agent \GenerationM74ethods
-  #
-  # This module handles everything related to prompt generation, from registering
-  # new generation methods to configuring the prompt object to be sent.
-  module GenerationMethods
-    extend ActiveSupport::Concern
-
-    included do
-      # Do not make this inheritable, because we always want it to propagate
-      cattr_accessor :raise_generation_errors, default: true
-      cattr_accessor :perform_generations, default: true
-
-      class_attribute :generation_methods, default: {}.freeze
-      class_attribute :generation_method, default: :smtp
-
-      add_generation_method :test, ActiveAgent::ActionPrompt::TestAgent
-    end
-
-    module ClassMethods
-      delegate :generations, :generations=, to: ActiveAgent::ActionPrompt::TestAgent
-
-      def add_generation_method(symbol, klass, default_options = {})
-        class_attribute(:"#{symbol}_settings") unless respond_to?(:"#{symbol}_settings")
-        public_send(:"#{symbol}_settings=", default_options)
-        self.generation_methods = generation_methods.merge(symbol.to_sym => klass).freeze
-      end
-
-      def wrap_generation_behavior(prompt, method = nil, options = nil) # :nodoc:
-        method ||= generation_method
-        prompt.generation_handler = self
-
-        case method
-        when NilClass
-          raise "Generation method cannot be nil"
-        when Symbol
-          if klass = generation_methods[method]
-            prompt.generation_method(klass, (send(:"#{method}_settings") || {}).merge(options || {}))
-          else
-            raise "Invalid generation method #{method.inspect}"
-          end
-        else
-          prompt.generation_method(method)
-        end
-
-        prompt.perform_generations = perform_generations
-        prompt.raise_generation_errors = raise_generation_errors
-      end
-    end
-
-    def wrap_generation_behavior!(*) # :nodoc:
-      self.class.wrap_generation_behavior(prompt, *)
-    end
-  end
-end