activeagent 0.5.0rc2 → 0.5.0rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d2af71e1d2c2bc28b9a7d2301efe45ec7252f7f749ec3e3e0385f813becff1f
-  data.tar.gz: d5bc0672d10326144407d3f1c8554768c84fc61206541dde8f15e366cb21ae2d
+  metadata.gz: 0f3087fa32e11e33dd1f48e093a8d92b38e11264bf403faa65f4a57c8e3b2a4b
+  data.tar.gz: 57ce989b2279b23d56ab3b40eba65877ec336bc056cc375f869b1caf301aad2f
 SHA512:
-  metadata.gz: a2f176f61abb5ab67321d70b56e858bd0ffb435636ebdad77c310c8656a43ae2086bc27a7d4b721b67061d5ac1530a7672ee23d7a3cfc104504c7a7666bbb998
-  data.tar.gz: 1398927382c0e9c73c17eb0c275e1696e49ea835537877f927f9f6ccc31cc8a7e7fdfb93ef4478b617e02a99221419b6e4a03bda2973e2b0efdf1293c4ed119f
+  metadata.gz: 25c0437d878f5c2452276614c23c868dfdcec6667906e546b13176916fd12edd30ae4f6c21296ad3a724f5382e82a71a84594b4563165076aa5b50c52b98f7a2
+  data.tar.gz: 0cef9d5c876bf9d235c0090dfd4d873da3d0508c8c77820c70d408df2595eae7d3e167ffe65644ebcc7faa5b5e361be81c56446ad5c106877a2d651407a6d8a9

data/README.md

@@ -1,5 +1,10 @@
-![Active Agent Logo](https://framerusercontent.com/images/oEx786EYW2ZVL4Xf9hparOVLjHI.png)
-> *Build AI in Rails*
+<picture>
+  <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*
+
+
 >
 > *Now Agents are Controllers*
 >
@@ -9,4 +14,175 @@
 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.
+[docs.activeagents.ai](https://docs.activeagents.ai) - The official documentation site for Active Agent.
+
+## Getting Started
+
+### Installation
+
+Use bundler to add activeagent to your Gemfile and install:
+```bash
+bundle add activeagent
+```
+
+Add the generation provider gem you want to use:
+
+```bash
+# OpenAI
+bundle add ruby-openai
+
+# Anthropic
+bundle add ruby-anthropic
+
+# Ollama (uses OpenAI-compatible API)
+bundle add ruby-openai
+
+# OpenRouter (uses OpenAI-compatible API)
+bundle add ruby-openai
+```
+
+### Setup
+
+Run the install generator to create the necessary configuration files:
+
+```bash
+rails generate active_agent:install
+```
+
+This creates:
+- `config/active_agent.yml`: Configuration file for generation providers
+- `app/agents`: Directory for your agent classes
+- `app/views/agent_*`: Directory for agent prompt/view templates
+
+### Quick Example
+
+Define an application agent:
+
+```ruby
+class ApplicationAgent < ActiveAgent::Base
+  generate_with :openai, 
+    instructions: "You are a helpful assistant.",
+    model: "gpt-4o-mini",
+    temperature: 0.7
+end
+```
+
+Use your agent:
+
+```ruby
+message = "Test Application Agent"
+prompt = ApplicationAgent.with(message: message).prompt_context
+response = prompt.generate_now
+```
+
+### Your First Agent
+
+Generate a new agent:
+
+```bash
+rails generate active_agent:agent TravelAgent search book confirm
+```
+
+This creates an agent with actions that can be called:
+
+```ruby
+class TravelAgent < ApplicationAgent
+  def search
+    # Your search logic here
+    prompt
+  end
+
+  def book
+    # Your booking logic here
+    prompt
+  end
+
+  def confirm
+    # Your confirmation logic here
+    prompt
+  end
+end
+```
+
+## Configuration
+
+Configure generation providers in `config/active_agent.yml`:
+
+```yaml
+development:
+  openai:
+    service: "OpenAI"
+    api_key: <%= Rails.application.credentials.dig(:openai, :api_key) %>
+    model: "gpt-4o-mini"
+    embeddings_model: "text-embedding-3-small"
+
+  anthropic:
+    service: "Anthropic"
+    api_key: <%= Rails.application.credentials.dig(:anthropic, :api_key) %>
+    model: "claude-3-5-sonnet"
+
+  ollama:
+    service: "Ollama"
+    model: "llama3.2"
+    embeddings_model: "nomic-embed-text"
+    host: "http://localhost:11434"
+```
+
+## Features
+
+- **Agent-Oriented Programming**: Build AI applications using familiar Rails patterns
+- **Multiple Provider Support**: Works with OpenAI, Anthropic, Ollama, and more
+- **Action-Based Design**: Define agent capabilities through actions
+- **View Templates**: Use ERB templates for prompts (text, JSON, HTML)
+- **Streaming Support**: Real-time response streaming with ActionCable
+- **Tool/Function Calling**: Agents can use tools to interact with external services
+- **Context Management**: Maintain conversation history across interactions
+- **Structured Output**: Define JSON schemas for predictable responses
+
+## Examples
+
+### Data Extraction
+Extract structured data from images, PDFs, and text:
+
+```ruby
+prompt = DataExtractionAgent.with(
+  output_schema: :chart_schema,
+  image_path: Rails.root.join("sales_chart.png")
+).parse_content
+```
+
+### Translation
+Translate text between languages:
+
+```ruby
+response = TranslationAgent.with(
+  message: "Hi, I'm Justin", 
+  locale: "japanese"
+).translate.generate_now
+```
+
+### Tool Usage
+Agents can use tools to perform actions:
+
+```ruby
+# Agent with tool support
+message = "Show me a cat"
+prompt = SupportAgent.with(message: message).prompt_context
+response = prompt.generate_now
+# Response includes tool call results
+```
+
+## Learn More
+
+- [Documentation](https://docs.activeagents.ai)
+- [Getting Started Guide](https://docs.activeagents.ai/docs/getting-started)
+- [API Reference](https://docs.activeagents.ai/docs/framework)
+- [Examples](https://docs.activeagents.ai/docs/agents)
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+## License
+
+Active Agent is released under the [MIT License](LICENSE).

data/lib/active_agent/action_prompt/base.rb

@@ -113,7 +113,6 @@ module ActiveAgent
             inherited_options = (self.options || {}).except(:instructions)
             self.options = inherited_options.merge(options)
           end
-          self.options[:stream] = new.agent_stream if self.options[:stream]
         end
 
         def stream_with(&stream)
@@ -182,7 +181,9 @@ module ActiveAgent
       attr_internal :context
 
       def agent_stream
-        proc do |message, delta, stop|
+        proc do |message, delta, stop, action_name|
+          @_action_name = action_name
+
           run_stream_callbacks(message, delta, stop) do |message, delta, stop|
             yield message, delta, stop if block_given?
           end
@@ -221,7 +222,6 @@ module ActiveAgent
       end
 
       def update_context(response)
-        context.message = context.messages.last
         ActiveAgent::GenerationProvider::Response.new(prompt: context)
       end
 
@@ -233,16 +233,21 @@ module ActiveAgent
 
       def perform_action(action)
         current_context = context.clone
-        process(action.name, *action.params)
-        context.messages.last.role = :tool
-        context.messages.last.action_id = action.id
-        context.messages.last.action_name = action.name
-        context.messages.last.generation_id = action.id
-        current_context.messages << context.messages.last
+        # Set params from the action for controller access
+        if action.params.is_a?(Hash)
+          self.params = action.params
+        end
+        process(action.name)
+        context.message.role = :tool
+        context.message.action_id = action.id
+        context.message.action_name = action.name
+        context.message.generation_id = action.id
+        current_context.message = context.message
+        current_context.messages << context.message
         self.context = current_context
       end
 
-      def initialize
+      def initialize # :nodoc:
         super
         @_prompt_was_called = false
         @_context = ActiveAgent::ActionPrompt::Prompt.new(options: self.class.options || {})
@@ -300,20 +305,21 @@ module ActiveAgent
       def prompt(headers = {}, &block)
         return context if @_prompt_was_called && headers.blank? && !block
 
-        # Apply option hierarchy: prompt options > agent options > config options
+        # Apply option hierarchy: prompt options > agent > 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)
-
+        context.options[:stream] = agent_stream if context.options[:stream]
         content_type = headers[:content_type]
 
         headers = apply_defaults(headers)
         context.messages = headers[:messages] || []
         context.context_id = headers[:context_id]
         context.params = params
+        context.action_name = action_name
 
         context.output_schema = load_schema(headers[:output_schema], set_prefixes(headers[:output_schema], lookup_context.prefixes))
 
@@ -414,10 +420,7 @@ module ActiveAgent
         # 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
 
@@ -495,8 +498,8 @@ module ActiveAgent
       def collect_responses_from_templates(headers)
         templates_path = headers[:template_path] || self.class.agent_name
         templates_name = headers[:template_name] || action_name
-
         each_template(Array(templates_path), templates_name).map do |template|
+          next if template.format == :json && headers[:format] != :json
           format = template.format || formats.first
           {
             body: render(template: template, formats: [ format ]),
@@ -532,6 +535,7 @@ module ActiveAgent
       end
 
       def prepare_instructions(instructions)
+        binding.irb
         case instructions
         when Hash
           raise ArgumentError, "Expected `:template` key in instructions hash" unless instructions[:template]

data/lib/active_agent/action_prompt/prompt.rb

@@ -4,7 +4,7 @@ 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, :output_schema
+      attr_accessor :actions, :body, :content_type, :context_id, :message, :options, :mime_version, :charset, :context, :parts, :params, :action_choice, :agent_class, :output_schema, :action_name
 
       def initialize(attributes = {})
         @options = attributes.fetch(:options, {})
@@ -26,6 +26,7 @@ module ActiveAgent
         @parts = attributes.fetch(:parts, [])
         @output_schema = attributes.fetch(:output_schema, nil)
         @messages = Message.from_messages(@messages)
+        @action_name = attributes.fetch(:action_name, nil)
         set_message if attributes[:message].is_a?(String) || @body.is_a?(String) && @message&.content
         set_messages if @instructions.present?
       end
@@ -56,10 +57,8 @@ module ActiveAgent
       end
 
       def add_part(message)
-        if @content_type == message.content_type && message.content.present?
-          @message = message
-          set_message
-        end
+        @message = message
+        set_message
 
         @parts << message
       end

data/lib/active_agent/callbacks.rb

@@ -11,26 +11,21 @@ module ActiveAgent
     end
 
     module ClassMethods
-      # Defines a callback that will get called right before the
-      # prompt is sent to the generation provider method.
-      def before_generation(*filters, &blk)
-        set_callback(:generation, :before, *filters, &blk)
-      end
-
-      # Defines a callback that will get called right after the
-      # prompt's generation method is finished.
-      def after_generation(*filters, &blk)
-        set_callback(:generation, :after, *filters, &blk)
-      end
-
-      # Defines a callback that will get called around the prompt's generation method.
-      def around_generation(*filters, &blk)
-        set_callback(:generation, :around, *filters, &blk)
+      # # Defines a callback that will get called right before/after/around the
+      # # generation provider method.
+      [ :before, :after, :around ].each do |callback|
+        define_method "#{callback}_generation" do |*names, &blk|
+          _insert_callbacks(names, blk) do |name, options|
+            set_callback(:generation, callback, name, options)
+          end
+        end
       end
 
       # Defines a callback for handling streaming responses during generation
-      def on_stream(*filters, &blk)
-        set_callback(:stream, :before, *filters, &blk)
+      def on_stream(*names, &blk)
+        _insert_callbacks(names, blk) do |name, options|
+          set_callback(:stream, :before, name, options)
+        end
       end
     end
 

data/lib/active_agent/generation_provider/anthropic_provider.rb

@@ -1,6 +1,12 @@
 # lib/active_agent/generation_provider/anthropic_provider.rb
 
-require "anthropic"
+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`."
+end
+
 require "active_agent/action_prompt/action"
 require_relative "base"
 require_relative "response"
@@ -10,9 +16,8 @@ module ActiveAgent
     class AnthropicProvider < Base
       def initialize(config)
         super
-        @api_key = config["api_key"]
-        @model_name = config["model"] || "claude-3-5-sonnet-20240620"
-        @client = Anthropic::Client.new(access_token: @api_key)
+        @access_token ||= config["api_key"] || config["access_token"] || Anthropic.configuration.access_token || ENV["ANTHROPIC_ACCESS_TOKEN"]
+        @client = Anthropic::Client.new(access_token: @access_token)
       end
 
       def generate(prompt)
@@ -40,7 +45,7 @@ module ActiveAgent
         proc do |chunk|
           if new_content = chunk.dig(:delta, :text)
             message.content += new_content
-            agent_stream.call(message) if agent_stream.respond_to?(:call)
+            agent_stream.call(message, nil, false, prompt.action_name) if agent_stream.respond_to?(:call)
           end
         end
       end

data/lib/active_agent/generation_provider/base.rb

@@ -4,7 +4,7 @@ module ActiveAgent
   module GenerationProvider
     class Base
       class GenerationProviderError < StandardError; end
-      attr_reader :client, :config, :prompt, :response
+      attr_reader :client, :config, :prompt, :response, :access_token, :model_name
 
       def initialize(config)
         @config = config

data/lib/active_agent/generation_provider/ollama_provider.rb

@@ -6,10 +6,10 @@ module ActiveAgent
     class OllamaProvider < OpenAIProvider
       def initialize(config)
         @config = config
-        @api_key = config["api_key"]
+        @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: @api_key, log_errors: true)
+        @client = OpenAI::Client.new(uri_base: @host, access_token: @access_token, log_errors: true)
       end
     end
   end

data/lib/active_agent/generation_provider/open_ai_provider.rb

@@ -15,14 +15,13 @@ module ActiveAgent
     class OpenAIProvider < Base
       def initialize(config)
         super
-        @api_key = config["api_key"]
-        @model_name = config["model"] || "gpt-4o-mini"
+        @host = config["host"] || nil
+        @access_token ||= config["api_key"] || config["access_token"] || OpenAI.configuration.access_token || ENV["OPENAI_ACCESS_TOKEN"]
+        @organization_id = config["organization_id"] || OpenAI.configuration.organization_id || ENV["OPENAI_ORGANIZATION_ID"]
+        @admin_token = config["admin_token"] || OpenAI.configuration.admin_token || ENV["OPENAI_ADMIN_TOKEN"]
+        @client = OpenAI::Client.new(access_token: @access_token, uri_base: @host, organization_id: @organization_id)
 
-        @client = if (@host = config["host"])
-          OpenAI::Client.new(uri_base: @host, access_token: @api_key)
-        else
-          OpenAI::Client.new(access_token: @api_key)
-        end
+        @model_name = config["model"] || "gpt-4o-mini"
       end
 
       def generate(prompt)
@@ -61,7 +60,7 @@ module ActiveAgent
             message.generation_id = chunk.dig("id")
             message.content += new_content
 
-            agent_stream.call(message, new_content, false) do |message, new_content|
+            agent_stream.call(message, new_content, false, prompt.action_name) do |message, new_content|
               yield message, new_content if block_given?
             end
           elsif chunk.dig("choices", 0, "delta", "tool_calls") && chunk.dig("choices", 0, "delta", "role")
@@ -70,7 +69,7 @@ module ActiveAgent
             @response = ActiveAgent::GenerationProvider::Response.new(prompt:, message:)
           end
 
-          agent_stream.call(message, nil, true) do |message|
+          agent_stream.call(message, nil, true, prompt.action_name) do |message|
             yield message, nil if block_given?
           end
         end

data/lib/active_agent/generation_provider/open_router_provider.rb

@@ -6,9 +6,9 @@ module ActiveAgent
     class OpenRouterProvider < OpenAIProvider
       def initialize(config)
         @config = config
-        @api_key = config["api_key"]
+        @access_token ||= config["api_key"] || config["access_token"] || ENV["OPENROUTER_API_KEY"] || ENV["OPENROUTER_ACCESS_TOKEN"]
         @model_name = config["model"]
-        @client = OpenAI::Client.new(uri_base: "https://openrouter.ai/api/v1", access_token: @api_key, log_errors: true)
+        @client = OpenAI::Client.new(uri_base: "https://openrouter.ai/api/v1", access_token: @access_token, log_errors: true)
       end
     end
   end

data/lib/active_agent/generation_provider/response.rb

@@ -10,6 +10,34 @@ module ActiveAgent
         @message = message || prompt.message
         @raw_response = raw_response
       end
+
+      # Extract usage statistics from the raw response
+      def usage
+        return nil unless @raw_response
+
+        # OpenAI/OpenRouter format
+        if @raw_response.is_a?(Hash) && @raw_response["usage"]
+          @raw_response["usage"]
+        # Anthropic format
+        elsif @raw_response.is_a?(Hash) && @raw_response["usage"]
+          @raw_response["usage"]
+        else
+          nil
+        end
+      end
+
+      # Helper methods for common usage stats
+      def prompt_tokens
+        usage&.dig("prompt_tokens")
+      end
+
+      def completion_tokens
+        usage&.dig("completion_tokens")
+      end
+
+      def total_tokens
+        usage&.dig("total_tokens")
+      end
     end
   end
 end

data/lib/active_agent/generation_provider.rb

@@ -12,17 +12,21 @@ module ActiveAgent
     end
 
     module ClassMethods
-      def configuration(provider_name, **options)
-        config = ActiveAgent.config[provider_name.to_s] || ActiveAgent.config.dig(ENV["RAILS_ENV"], provider_name.to_s)
+      def configuration(name_or_provider, **options)
+        config = ActiveAgent.config[name_or_provider.to_s] || ActiveAgent.config.dig(ENV["RAILS_ENV"], name_or_provider.to_s) || {}
 
-        raise "Configuration not found for provider: #{provider_name}" unless config
+        config = { "service" => "OpenAI" } if config.empty? && name_or_provider == :openai
         config.merge!(options)
+      raise "Failed to load provider #{name_or_provider}: configuration not found for provider"  if config["service"].nil?
         configure_provider(config)
+      rescue LoadError => e
+        raise RuntimeError, "Failed to load provider #{name_or_provider}: #{e.message}"
       end
 
       def configure_provider(config)
-        require "active_agent/generation_provider/#{config["service"].underscore}_provider"
-        ActiveAgent::GenerationProvider.const_get("#{config["service"].camelize}Provider").new(config)
+        service_name = config["service"]
+        require "active_agent/generation_provider/#{service_name.underscore}_provider"
+        ActiveAgent::GenerationProvider.const_get("#{service_name.camelize}Provider").new(config)
       end
 
       def generation_provider
@@ -40,6 +44,9 @@ module ActiveAgent
         when Symbol, String
           provider = configuration(name_or_provider)
           assign_provider(name_or_provider.to_s, provider)
+        when OpenAI::Client
+          name = :openai
+          assign_provider(name, name_or_provider)
         else
           raise ArgumentError
         end

data/lib/active_agent/version.rb

@@ -1,3 +1,3 @@
 module ActiveAgent
-  VERSION = "0.5.0rc2"
+  VERSION = "0.5.0rc3"
 end

data/lib/active_agent.rb

@@ -56,6 +56,8 @@ module ActiveAgent
         config_file = YAML.load(ERB.new(File.read(file)).result, aliases: true)
         env = ENV["RAILS_ENV"] || ENV["ENV"] || "development"
         @config = config_file[env] || config_file
+      else
+        @config = {}
       end
     end
   end

data/lib/generators/USAGE

@@ -3,23 +3,45 @@ Description:
     configuration files and application agent class.
 
     This generator creates:
-    - Configuration file (config/active_agent.yml)
+    - Configuration file (config/active_agent.yml) unless --skip-config is used
     - Application agent base class (app/agents/application_agent.rb)
     - Layout templates for agent views (via template engine hooks)
 
+Options:
+    --skip-config         Skip the creation of config/active_agent.yml
+    --formats=FORMAT      Specify formats to generate layouts for (default: text)
+                          Can be one or more of: text, html, json
+                          Example: --formats=text html json
+
 Examples:
     `bin/rails generate active_agent:install`
 
-    creates the basic ActiveAgent setup:
+    creates the basic ActiveAgent setup with default text format:
         Config:     config/active_agent.yml
         Base Agent: app/agents/application_agent.rb
-        Layouts:    app/views/layouts/agent.html.erb
-                    app/views/layouts/agent.text.erb
+        Layout:     app/views/layouts/agent.text.erb
+
+    `bin/rails generate active_agent:install --formats=text html json`
+
+    creates ActiveAgent setup with all format layouts:
+        Config:     config/active_agent.yml
+        Base Agent: app/agents/application_agent.rb
+        Layouts:    app/views/layouts/agent.text.erb
+                    app/views/layouts/agent.html.erb
                     app/views/layouts/agent.json.erb
 
-    `bin/rails generate active_agent:install --template-engine=haml`
+    `bin/rails generate active_agent:install --skip-config`
 
-    creates ActiveAgent setup with Haml layouts instead of ERB.
+    creates ActiveAgent setup without configuration file:
+        Base Agent: app/agents/application_agent.rb
+        Layout:     app/views/layouts/agent.text.erb
+
+    `bin/rails generate active_agent:install --skip-config --formats=html json`
+
+    creates ActiveAgent setup without config file but with HTML and JSON layouts:
+        Base Agent: app/agents/application_agent.rb
+        Layouts:    app/views/layouts/agent.html.erb
+                    app/views/layouts/agent.json.erb
 
     After running this generator, you can create individual agents with:
     `bin/rails generate active_agent:agent AGENT_NAME ACTION_NAME`

data/lib/generators/active_agent/USAGE

@@ -6,25 +6,51 @@ Description:
     engine and test framework generators. If no ApplicationAgent exists,
     it will be created automatically.
 
-    Views are created for each action in three formats:
-    - HTML (.html.erb) - for rich text responses
-    - Text (.text.erb) - for plain text responses  
-    - JSON (.json.erb) - for structured function calling responses
+    By default, only text format views are created. You can specify which
+    formats to generate using the --formats option:
+    - text (.text.erb) - for plain text responses (default)
+    - html (.html.erb) - for rich text responses
+    - json (.json.erb) - for structured function calling responses
+
+Options:
+    --formats=FORMAT      Specify formats to generate views for (default: text)
+                          Can be one or more of: text, html, json
+                          Example: --formats=text html json
 
 Examples:
     `bin/rails generate active_agent:agent inventory search`
 
-    creates an inventory agent class, views, and test:
+    creates an inventory agent class with text format view and test:
+        Agent:      app/agents/inventory_agent.rb
+        View:       app/views/inventory_agent/search.text.erb
+        Test:       test/agents/inventory_agent_test.rb
+
+    `bin/rails generate active_agent:agent inventory search --formats=html json`
+
+    creates an inventory agent with html and json views:
         Agent:      app/agents/inventory_agent.rb
         Views:      app/views/inventory_agent/search.html.erb
-                    app/views/inventory_agent/search.text.erb
                     app/views/inventory_agent/search.json.erb
         Test:       test/agents/inventory_agent_test.rb
 
-    `bin/rails generate active_agent:agent inventory search update report`
+    `bin/rails generate active_agent:agent inventory search update report --formats=text html json`
 
-    creates an inventory agent with search, update, and report actions.
+    creates an inventory agent with search, update, and report actions in all formats:
+        Agent:      app/agents/inventory_agent.rb
+        Views:      app/views/inventory_agent/search.text.erb
+                    app/views/inventory_agent/search.html.erb
+                    app/views/inventory_agent/search.json.erb
+                    app/views/inventory_agent/update.text.erb
+                    app/views/inventory_agent/update.html.erb
+                    app/views/inventory_agent/update.json.erb
+                    app/views/inventory_agent/report.text.erb
+                    app/views/inventory_agent/report.html.erb
+                    app/views/inventory_agent/report.json.erb
+        Test:       test/agents/inventory_agent_test.rb
 
-    `bin/rails generate active_agent:agent admin/user create --template-engine=haml`
+    `bin/rails generate active_agent:agent admin/user create --formats=json`
 
-    creates a namespaced admin/user agent with Haml templates.
+    creates a namespaced admin/user agent with only JSON view for API responses:
+        Agent:      app/agents/admin/user_agent.rb
+        View:       app/views/admin/user_agent/create.json.erb
+        Test:       test/agents/admin/user_agent_test.rb

data/lib/generators/active_agent/agent_generator.rb

@@ -4,8 +4,8 @@ module ActiveAgent
   module Generators
     class AgentGenerator < ::Rails::Generators::NamedBase
       source_root File.expand_path("templates", __dir__)
-
       argument :actions, type: :array, default: [], banner: "method method"
+      class_option :formats, type: :array, default: [ "text" ], desc: "Specify formats to generate (text, html, json)"
 
       check_class_collision suffix: "Agent"
 
@@ -23,6 +23,10 @@ module ActiveAgent
 
       private
 
+      def formats
+        options[:formats].map(&:to_sym)
+      end
+
       def file_name # :doc:
         @_file_name ||= super.sub(/_agent\z/i, "")
       end

data/lib/generators/active_agent/install_generator.rb

@@ -3,15 +3,16 @@
 module ActiveAgent
   module Generators
     class InstallGenerator < ::Rails::Generators::Base
+      class_option :skip_config, type: :boolean, default: false, desc: "Skip configuration file generation"
+      class_option :formats, type: :array, default: [ "text" ], desc: "Specify formats to generate (text, html, json)"
+
       def self.usage_path
         @usage_path ||= File.expand_path("../USAGE", __dir__)
       end
       source_root File.expand_path("templates", __dir__)
 
-      hook_for :template_engine, :test_framework
-
       def create_configuration
-        template "active_agent.yml", "config/active_agent.yml"
+        template "active_agent.yml", "config/active_agent.yml" unless options[:skip_config]
       end
 
       def create_application_agent
@@ -22,7 +23,12 @@ module ActiveAgent
         end
       end
 
+      hook_for :template_engine
+
       private
+      def formats
+        options[:formats].map(&:to_sym)
+      end
 
       def application_agent_file_name
         "app/agents/application_agent.rb"

data/lib/generators/active_agent/templates/application_agent.rb.tt

@@ -1,7 +1,7 @@
 <% module_namespacing do -%>
 class ApplicationAgent < ActiveAgent::Base
-  layout 'agent'
-  
+  layout "agent"
+
   generate_with :openai, model: "gpt-4o-mini", instructions: "You are a helpful assistant."
 end
-<% end %>
+<% end %>

data/lib/generators/erb/agent_generator.rb

@@ -7,6 +7,7 @@ module Erb # :nodoc:
     class AgentGenerator < Base # :nodoc:
       source_root File.expand_path("templates", __dir__)
       argument :actions, type: :array, default: [], banner: "method method"
+      class_option :formats, type: :array, default: [ "text" ], desc: "Specify formats to generate (text, html, json)"
 
       def copy_view_files
         view_base_path = File.join("app/views", class_path, file_name + "_agent")
@@ -30,9 +31,8 @@ module Erb # :nodoc:
       end
 
       private
-
       def formats
-        [ :text, :html, :json ]
+        options[:formats].map(&:to_sym)
       end
 
       def file_name

data/lib/generators/erb/install_generator.rb

@@ -1,16 +1,36 @@
 # frozen_string_literal: true
 
-require "rails/generators"
-
 module Erb # :nodoc:
   module Generators # :nodoc:
     class InstallGenerator < ::Rails::Generators::Base # :nodoc:
       source_root File.expand_path("templates", __dir__)
+      class_option :formats, type: :array, default: [ "text" ], desc: "Specify formats to generate (text, html, json)"
 
       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"
+        if behavior == :invoke
+          formats.each do |format|
+            puts format
+            layout_path = File.join("app/views/layouts", filename_with_extensions("agent", format))
+            template filename_with_extensions(:layout, format), layout_path unless File.exist?(layout_path)
+          end
+        end
+      end
+
+      private
+      def formats
+        options[:formats].map(&:to_sym)
+      end
+
+      def file_name
+        @_file_name ||= super.sub(/_agent\z/i, "")
+      end
+
+      def filename_with_extensions(name, file_format = format)
+        [ name, file_format, handler ].compact.join(".")
+      end
+
+      def handler
+        :erb
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeagent
 version: !ruby/object:Gem::Version
-  version: 0.5.0rc2
+  version: 0.5.0rc3
 platform: ruby
 authors:
 - Justin Bowen
@@ -190,7 +190,6 @@ files:
 - lib/generators/active_agent/templates/application_agent.rb.tt
 - lib/generators/erb/agent_generator.rb
 - lib/generators/erb/install_generator.rb
-- lib/generators/erb/templates/application_agent.rb.tt
 - lib/generators/erb/templates/layout.html.erb.tt
 - lib/generators/erb/templates/layout.json.erb.tt
 - lib/generators/erb/templates/layout.text.erb.tt

data/lib/generators/erb/templates/application_agent.rb.tt

@@ -1,7 +0,0 @@
-<% module_namespacing do -%>
-class ApplicationAgent < ActiveAgent::Base
-  layout 'agent'
-  
-  generate_with :openai, model: "gpt-4o-mini", instructions: "You are a helpful assistant."
-end
-<% end %>