llama_bot_rails 0.1.13 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73211770ce4e13b9fb835721ed12f0d422889a84d0c45473174b7bf97ff76e93
-  data.tar.gz: b70b8fdcc9375f45d317427cd62546c3d2190fab82d9769f50afeaabc3af4870
+  metadata.gz: 4a2a7cba5de6b95658edf2f1445ddd883bf0fa7b6f0a844fc7b65d75696bbe93
+  data.tar.gz: 471a4c54a3f26dd4d6b68c6d208d3c8e553cfcf2933436bad3e7b30af2d50296
 SHA512:
-  metadata.gz: c7b9a928144a765964510b4e1d2ce51a0736b3105a083503f98cb7681e229a6e7fd2c7d9246c13ee9233f04adbd2448d03bc4dfd626b550bbb8c38bf848cbbdb
-  data.tar.gz: e94b2ee65ac23a81ba952bfd14fd2679c442a80058f42743cd06c0c132dd6164dcebdca885c1979eeeeac89732ae4fa2726d51266669df2834a4a85ae1a8d857
+  metadata.gz: 49afcfcec2697177cccc266cbdca5b7b0859feef23fb45d2626435c686368e0231d9cf0c66b894a3a0696dc50d54c9e285fc6b66905b42be752ac24126c82d97
+  data.tar.gz: ada3ecb0a74f2fef56122ffcc97889b7c877d670296a5f8a556d3afad685b53332f7be4306cfdf901f2b00744f8fd600c56041605aef02db666d9e51fe633a72

data/app/channels/llama_bot_rails/chat_channel.rb

@@ -88,6 +88,16 @@ module LlamaBotRails
           end
         end
 
+        # Close the external WebSocket connection BEFORE stopping async tasks
+        if @external_ws_connection
+          begin
+            @external_ws_connection.close
+            Rails.logger.info "👋 [LlamaBot] Gracefully closed external WebSocket connection for: #{connection_id}"
+          rescue => e
+            Rails.logger.warn "❌ [LlamaBot] Could not close WebSocket connection: #{e.message}"
+          end
+        end
+
         # Clean up async tasks with better error handling
         begin
           @listener_task&.stop rescue nil
@@ -97,16 +107,6 @@ module LlamaBotRails
           Rails.logger.error "[LlamaBot] Error stopping async tasks: #{e.message}"
         end
         
-        # Clean up the connection
-        if @external_ws_connection
-          begin
-            @external_ws_connection.close
-            Rails.logger.info "[LlamaBot] Closed external WebSocket connection for: #{connection_id}"
-          rescue => e
-            Rails.logger.warn "[LlamaBot] Could not close WebSocket connection: #{e.message}"
-          end
-        end
-        
         # Force garbage collection in development/test environments to help clean up
         if !Rails.env.production?
           GC.start
@@ -138,7 +138,7 @@ module LlamaBotRails
 
         builder = state_builder_class.new(
           params: data,
-          context: { api_token: @api_token }
+          context: { api_token: @api_token }.with_indifferent_access
         )
 
         # 2. Construct the LangGraph-ready state
@@ -253,84 +253,82 @@ module LlamaBotRails
           # Wait for tasks to complete or connection to close
           [@listener_task, @keepalive_task].each(&:wait)
         rescue => e
-          Rails.logger.error "[LlamaBot] Failed to connect to external WebSocket for connection #{connection_id}: #{e.message}"
+          Rails.logger.error "❌ [LlamaBot] Failed to connect to external WebSocket for connection #{connection_id}: #{e.message}"
         ensure
           # Clean up tasks if they exist
           @listener_task&.stop
           @keepalive_task&.stop
-          @external_ws_connection&.close
+          if @external_ws_connection
+            @external_ws_connection.close
+            Rails.logger.info "👋 [LlamaBot] Cleaned up external WebSocket connection in ensure block"
+          end
         end
       end
     end
 
     # Listen for messages from the LlamaBot Backend
     def listen_to_external_websocket(connection)
-      while message = connection.read
+      begin
+        while message = connection.read
+          # Extract the actual message content
+          message_content = message.buffer if message.buffer
+          next unless message_content.present?
 
-        #Try to fix the ping/pong issue keepliave
-        # if message.type == :ping
-        
-        #   # respond with :pong
-        #   connection.write(Async::WebSocket::Messages::ControlFrame.new(:pong, frame.data))
-        #   connection.flush
-        #   next
-        # end
-        # Extract the actual message content
-        if message.buffer
-          message_content = message.buffer  # Use .data to get the message content
-        else
-          message_content = message.content
-        end
+          Rails.logger.info "[LlamaBot] Received from external WebSocket: #{message_content}"
 
-        Rails.logger.info "[LlamaBot] Received from external WebSocket: #{message_content}"
-        
-        begin
-          parsed_message = JSON.parse(message_content)
-          
-          if parsed_message["type"] != "pong"
-            # byebug
-          end
-          
-          case parsed_message["type"]
-          when "ai"
-            # Add any additional handling for write_code messages here
-            formatted_message = { message: {type: "ai", content: parsed_message['content'], base_message: parsed_message["base_message"]} }.to_json
-          when "tool"
-            # Add any additional handling for tool messages here
-            formatted_message = { message: {type: "tool", content: parsed_message['content'], base_message: parsed_message["base_message"]} }.to_json
-          when "error"
-            Rails.logger.error "[LlamaBot] ---------Received error message!----------"
-            response = parsed_message['content']
-            formatted_message = { message: message_content }.to_json
-            Rails.logger.error "[LlamaBot] ---------------------> Response: #{response}"
-            Rails.logger.error "[LlamaBot] ---------Completed error message!----------"
-          when "pong"
-            # Tell llamabot frontend that we've received a pong response, and we're still connected
-            formatted_message = { message: {type: "pong"} }.to_json
+          begin
+            parsed_message = JSON.parse(message_content)
+            
+            formatted_message = { message: {type: parsed_message["type"], content: parsed_message['content'], base_message: parsed_message["base_message"]} }.to_json
+            case parsed_message["type"]
+            when "error"
+              Rails.logger.error "[LlamaBot] ---------Received error message!----------"
+              response = parsed_message['content']
+              formatted_message = { message: message_content }.to_json
+              Rails.logger.error "[LlamaBot] ---------------------> Response: #{response}"
+              Rails.logger.error "[LlamaBot] ---------Completed error message!----------"
+            when "pong"
+              # Tell llamabot frontend that we've received a pong response, and we're still connected
+              formatted_message = { message: {type: "pong"} }.to_json
+            end
+            ActionCable.server.broadcast "chat_channel_#{params[:session_id]}", formatted_message
+          rescue JSON::ParserError => e
+            Rails.logger.error "[LlamaBot] Failed to parse message as JSON: #{e.message}"
+            # Continue to the next message without crashing the listener.
+            next
           end
-        rescue JSON::ParserError => e
-          Rails.logger.error "[LlamaBot] Failed to parse message as JSON: #{e.message}"
         end
-        ActionCable.server.broadcast "chat_channel_#{params[:session_id]}", formatted_message
+      rescue IOError, Errno::ECONNRESET => e
+        # This is a recoverable error. Log it and allow the task to end gracefully.
+        # The `ensure` block in `setup_external_websocket` will handle the cleanup.
+        Rails.logger.warn "❌ [LlamaBot] Connection lost while listening: #{e.message}. The connection will be closed."
       end
     end
 
     ###
     def send_keep_alive_pings(connection)
       loop do
-        ping_message = {
-          type: 'ping',
-          connection_id: @connection_id,
-          connection_state: !connection.closed? ? 'connected' : 'disconnected',
-          connection_class: connection.class.name
-        }.to_json
-        connection.write(ping_message)
-        connection.flush
-        Rails.logger.debug "[LlamaBot] Sent keep-alive ping: #{ping_message}"
+        # Stop the loop gracefully if the connection has already been closed.
+        break if connection.closed?
+        
+        begin
+          ping_message = {
+            type: 'ping',
+            connection_id: @connection_id,
+            connection_state: !connection.closed? ? 'connected' : 'disconnected',
+            connection_class: connection.class.name
+          }.to_json
+          connection.write(ping_message)
+          connection.flush
+          Rails.logger.debug "[LlamaBot] Sent keep-alive ping: #{ping_message}"
+        rescue IOError, Errno::ECONNRESET => e
+          Rails.logger.warn "❌ [LlamaBot] Could not send ping, connection likely closed: #{e.message}"
+          # Break the loop to allow the task to terminate gracefully.
+          break
+        end
+
         Async::Task.current.sleep(30)
       end
-    rescue => e
-      Rails.logger.error "[LlamaBot] Error in keep-alive ping: #{e.message} | Connection type: #{connection.class.name}"
     end
 
     # Send messages from the user to the LlamaBot Backend Socket

data/app/controllers/llama_bot_rails/agent_controller.rb

@@ -100,7 +100,7 @@ module LlamaBotRails
             # 1. Instantiate the builder
             builder = state_builder_class.new(
                 params: params,
-                context: { api_token: @api_token }
+                context: { api_token: @api_token }.with_indifferent_access
             )
     
             # 2. Construct the LangGraph-ready state

data/app/views/llama_bot_rails/agent/chat.html.erb

@@ -586,7 +586,7 @@
     let currentThreadId = null;
     let isSidebarCollapsed = false;
     let streamingTimeout = null;
-    const STREAMING_TIMEOUT_MS = 30000; // 30 seconds timeout
+    const STREAMING_TIMEOUT_MS = 3000000; // 3000 seconds timeout
 
     // Initialize the app
     document.addEventListener('DOMContentLoaded', function() {
@@ -968,6 +968,7 @@
                     }
                     
                   } catch (parseError) {
+                    addMessage(`Error: ${parseError} - Data: ${jsonData}`, 'error');
                     console.error('Error parsing SSE data:', parseError, 'Data:', jsonData);
                   }
                 }

data/app/views/llama_bot_rails/agent/chat_ws.html.erb

@@ -659,7 +659,10 @@ This deprecated and will be removed over time.
         },
         received(data) {
           const parsedData = JSON.parse(data).message;
+          console.log("LLM Response:", parsedData);
           switch (parsedData.type) {
+            case "AIMessageChunk":
+              addMessage(parsedData.content, parsedData.type, parsedData.base_message);
             case "ai":
               addMessage(parsedData.content, parsedData.type, parsedData.base_message);
               break;
@@ -966,6 +969,11 @@ This deprecated and will be removed over time.
       const messageDiv = document.createElement('div');
       messageDiv.className = `message ${sender}-message`;
       
+      if (sender == "AIMessageChunk"){
+        console.log("AIMessageChunk" + base_message);
+        messageDiv.innerHTML += text;
+      }
+      
       // Parse markdown for bot messages using Snarkdown, keep plain text for user messages
       if (sender === 'ai') { //Arghh. We're having issues with difference in formats between when we're streaming from updates mode, and when pulling state from checkpoint.
         if (text == ''){ //this is most likely a tool call.
@@ -1151,7 +1159,8 @@ This deprecated and will be removed over time.
 
         }
         else {
-          messageDiv.innerHTML = snarkdown(text); 
+          messageDiv.innerHTML = text;
+//          messageDiv.innerHTML = snarkdown(text); 
         }
       } else if (sender === 'tool') { //tool messages are not parsed as markdown
         if (base_message.name == 'run_rails_console_command') {

data/lib/generators/llama_bot_rails/install/templates/agent_state_builder.rb.erb

@@ -11,9 +11,9 @@ module <%= app_name %>
 
     def build
       {
-        message: @params[:message], # Rails param from JS/chat UI. This is the user's message to the agent.
-        thread_id: @context[:thread_id], # This is the thread id for the agent. It is used to track the conversation history.
-        api_token: @context[:api_token], # This is an authenticated API token for the agent, so that it can authenticate with us. (It may need access to resources on our Rails app, such as the Rails Console.)
+        message: @params["message"], # Rails param from JS/chat UI. This is the user's message to the agent.
+        thread_id: @params["thread_id"], # This is the thread id for the agent. It is used to track the conversation history.
+        api_token: @context["api_token"], # This is an authenticated API token for the agent, so that it can authenticate with us. (It may need access to resources on our Rails app, such as the Rails Console.)
         agent_prompt: LlamaBotRails.agent_prompt_text, # System prompt instructions for the agent. Can be customized in app/llama_bot/prompts/agent_prompt.txt
         agent_name: "llamabot" # This routes to the appropriate LangGraph agent as defined in LlamaBot/langgraph.json, and enables us to access different agents on our LlamaBot server.
       }

data/lib/llama_bot_rails/agent_auth.rb

@@ -5,7 +5,10 @@ module LlamaBotRails
   
       included do
         # Add before_action filter to automatically check agent authentication for LlamaBot requests
-        before_action :check_agent_authentication, if: :should_check_agent_auth?
+
+        if self < ActionController::Base
+          before_action :check_agent_authentication, if: :should_check_agent_auth?
+        end
         
         # ------------------------------------------------------------------
         # 1) For every Devise scope, alias authenticate_<scope>! so it now

data/lib/llama_bot_rails/agent_auth_2.rb

@@ -0,0 +1,149 @@
+# lib/llama_bot_rails/agent_auth.rb
+module LlamaBotRails
+    module AgentAuth
+      extend ActiveSupport::Concern
+      AUTH_SCHEME = "LlamaBot"
+  
+      included do
+        # ------------------------------------------------------------------
+        # Use the right callback macro for the including class:
+        #   • Controllers → before_action (old behaviour)
+        #   • ActiveJob   → before_perform  (uses same checker)
+        #   • Anything
+        #     else       → do nothing
+        # ------------------------------------------------------------------
+        if respond_to?(:before_action)
+          before_action :check_agent_authentication, if: :should_check_agent_auth?
+        elsif respond_to?(:before_perform)
+          before_perform :check_agent_authentication
+        end
+  
+        # ------------------------------------------------------------------
+        # 1) For every Devise scope, alias authenticate_<scope>! so it now
+        #    accepts *either* a logged-in browser session OR a valid agent
+        #    token. Existing before/skip filters keep working.
+        # ------------------------------------------------------------------
+        if defined?(Devise)
+          Devise.mappings.keys.each do |scope|
+            scope_filter = :"authenticate_#{scope}!"
+  
+            alias_method scope_filter, :authenticate_user_or_agent! \
+              if method_defined?(scope_filter)
+  
+            define_method(scope_filter) do |*args|
+              Rails.logger.warn(
+                "#{scope_filter} is now handled by LlamaBotRails::AgentAuth "\
+                "and will be removed in a future version. "\
+                "Use authenticate_user_or_agent! instead."
+              )
+              authenticate_user_or_agent!(*args)
+            end
+          end
+        end
+  
+        # ------------------------------------------------------------------
+        # 2) If Devise isn’t loaded at all, fall back to one alias so apps
+        #    that had authenticate_user! manually defined don’t break.
+        # ------------------------------------------------------------------
+        unless defined?(Devise)
+          original_authenticate_user =
+            instance_method(:authenticate_user!) if method_defined?(:authenticate_user!)
+  
+          define_method(:authenticate_user!) do |*args|
+            authenticate_user_or_agent!(*args)
+          end
+        end
+      end
+  
+      # --------------------------------------------------------------------
+      # Public helper: true if the request carries a *valid* agent token
+      # --------------------------------------------------------------------
+      def should_check_agent_auth?
+        # Skip if a Devise user is already signed in
+        return false if devise_user_signed_in?
+        llama_bot_request?
+      end
+  
+      def llama_bot_request?
+        return false unless respond_to?(:request) && request&.headers
+        scheme, token = request.headers["Authorization"]&.split(" ", 2)
+        Rails.logger.debug("[LlamaBot] auth header = #{scheme.inspect} #{token&.slice(0,8)}…")
+        return false unless scheme == AUTH_SCHEME && token.present?
+  
+        Rails.application.message_verifier(:llamabot_ws).verify(token)
+        true
+      rescue ActiveSupport::MessageVerifier::InvalidSignature
+        false
+      end
+  
+      private
+  
+      # --------------------------------------------------------------------
+      # Automatic check for LlamaBot requests
+      # --------------------------------------------------------------------
+      def check_agent_authentication
+        # Jobs don’t have a request object, so skip token logic there
+        return if is_a?(ActiveJob::Base)
+  
+        has_permitted_actions = self.class.respond_to?(:llama_bot_permitted_actions)
+        return unless has_permitted_actions
+  
+        is_llama_request      = llama_bot_request?
+        action_is_whitelisted = self.class.llama_bot_permitted_actions.include?(action_name)
+  
+        if is_llama_request
+          unless action_is_whitelisted
+            Rails.logger.warn("[LlamaBot] Action '#{action_name}' isn't white-listed for LlamaBot.")
+            render json: { error: "Action '#{action_name}' isn't white-listed for LlamaBot." },
+                   status: :forbidden
+          end
+        elsif action_is_whitelisted
+          Rails.logger.warn("[LlamaBot] Action '#{action_name}' requires LlamaBot authentication.")
+          render json: { error: "Action '#{action_name}' requires LlamaBot authentication" },
+                 status: :forbidden
+        end
+      end
+  
+      # --------------------------------------------------------------------
+      # Unified guard — browser OR agent
+      # --------------------------------------------------------------------
+      def devise_user_signed_in?
+        return false unless defined?(Devise)
+        return false unless respond_to?(:request) && request&.env
+        request.env["warden"]&.authenticated?
+      end
+  
+      def authenticate_user_or_agent!(*)
+        return if devise_user_signed_in?             # any logged-in Devise scope
+  
+        if llama_bot_request?
+          scheme, token = request.headers["Authorization"]&.split(" ", 2)
+          data = Rails.application.message_verifier(:llamabot_ws).verify(token)
+  
+          allowed = self.class.respond_to?(:llama_bot_permitted_actions) &&
+                    self.class.llama_bot_permitted_actions.include?(action_name)
+  
+          if allowed
+            user_object = LlamaBotRails.user_resolver.call(data[:user_id])
+            unless LlamaBotRails.sign_in_method.call(request.env, user_object)
+              head :unauthorized
+            end
+            return                                   # ✅ token + allow-listed action
+          else
+            Rails.logger.warn("[LlamaBot] Action '#{action_name}' isn't white-listed for LlamaBot.")
+            render json: { error: "Action '#{action_name}' isn't white-listed for LlamaBot." },
+                   status: :forbidden
+            return false
+          end
+        end
+  
+        # Fall back to Devise or plain 401
+        if defined?(Devise) && respond_to?(:request) && request&.env
+          request.env["warden"].authenticate!
+        else
+          head :unauthorized
+        end
+      end
+    end
+  end
+  

data/lib/llama_bot_rails/agent_state_builder.rb

@@ -6,17 +6,17 @@ module LlamaBotRails
         @context = context
       end
       
-
       # Warning: Types must match exactly or you'll get Pydantic errors. It's brittle - If these don't match exactly what's in nodes.py LangGraph state pydantic types, (For example, having a null value/None type when it should be a string) it will the agent.. 
       # So if it doesn't map state types properly from the frontend, it will break. (must be exactly what's defined here).
       # There won't be an exception thrown -- instead, you'll get an pydantic error message showing up in the BaseMessage content field. (In my case, it was a broken ToolMessage, but serializes from the inherited BaseMessage)
-      def build 
+      def build
         {
-          message: @params[:message], # Rails param from JS/chat UI. This is the user's message to the agent.
-          thread_id: @params[:thread_id], # This is the thread id for the agent. It is used to track the conversation history.
-          api_token: @context[:api_token], # This is an authenticated API token for the agent, so that it can authenticate with us. (It may need access to resources on our Rails app, such as the Rails Console.)
+          message: @params["message"], # Rails param from JS/chat UI. This is the user's message to the agent.
+          thread_id: @params["thread_id"], # This is the thread id for the agent. It is used to track the conversation history.
+          api_token: @context["api_token"], # This is an authenticated API token for the agent, so that it can authenticate with us. (It may need access to resources on our Rails app, such as the Rails Console.)
           agent_prompt: LlamaBotRails.agent_prompt_text, # System prompt instructions for the agent. Can be customized in app/llama_bot/prompts/agent_prompt.txt
-          agent_name: "llamabot" #This routes to the appropriate LangGraph agent as defined in LlamaBot/langgraph.json, and enables us to access different agents on our LlamaBot server.
+          agent_name: "llamabot", #This routes to the appropriate LangGraph agent as defined in LlamaBot/langgraph.json, and enables us to access different agents on our LlamaBot server.
+          available_routes: @context[:available_routes] # This is an array of routes that the agent can access. It is used to track the conversation history.
         }
       end
     end

data/lib/llama_bot_rails/llama_bot.rb

@@ -30,6 +30,9 @@ module LlamaBotRails
       http = Net::HTTP.new(uri.host, uri.port)
       
       request = Net::HTTP::Post.new(uri)
+      
+      http.use_ssl = (uri.scheme == "https")
+
       request['Content-Type'] = 'application/json'
       request.body = agent_params.to_json
 

data/lib/llama_bot_rails/route_helper.rb

@@ -0,0 +1,117 @@
+module LlamaBotRails
+  module RouteHelper
+    # Extracts the description from YARD comments
+    def self.extract_yard_description(comment_text)
+      comment_text.lines.map { |l| l.sub(/^# ?/, '') }
+                  .take_while { |l| !l.strip.start_with?('@') }
+                  .join(' ').strip
+    end
+
+    # Extracts a specific YARD tag from comments
+    def self.extract_yard_tag(comment_text, tag)
+      if match = comment_text.match(/@#{tag} (.+)/)
+        match[1].strip
+      end
+    end
+
+    # Main method: returns XML string of formatted routes for allowed_routes
+    def self.formatted_routes_xml(allowed_routes)
+      xml_routes = ""
+      allowed_routes.each do |route_str|
+        controller, action = route_str.split('#')
+        matching_routes = Rails.application.routes.routes.select do |r|
+          r.defaults[:controller] == controller && r.defaults[:action] == action
+        end
+
+        matching_routes.each do |r|
+          verb = r.verb.to_s.gsub(/[$^]/, '') # Handles both Regexp and String
+          path = r.path.spec.to_s
+          path_params = path.scan(/:\w+/).map { |p| p[1..-1] } # e.g. ["id"]
+
+          # Extract controller class and strong parameters
+          controller_class = "#{controller.camelize}Controller".safe_constantize
+          strong_params = []
+          yard_metadata = {}
+
+          if controller_class
+            # Extract YARD documentation for the action
+            begin
+              method_obj = controller_class.instance_method(action.to_sym)
+              source_location = method_obj.source_location
+              if source_location
+                file_path, line_number = source_location
+                file_lines = File.readlines(file_path)
+                # Look for YARD comments above the method
+                comment_lines = []
+                current_line = line_number - 2 # Start above the method definition
+                while current_line >= 0 && file_lines[current_line].strip.start_with?('#')
+                  comment_lines.unshift(file_lines[current_line].strip)
+                  current_line -= 1
+                end
+                # Parse YARD tags
+                comment_text = comment_lines.join("\n")
+                yard_metadata[:description] = extract_yard_description(comment_text)
+                yard_metadata[:tool_description] = extract_yard_tag(comment_text, 'tool_description')
+                yard_metadata[:example] = extract_yard_tag(comment_text, 'example')
+                yard_metadata[:params] = extract_yard_tag(comment_text, 'params')
+              end
+            rescue => e
+              # Silently continue if YARD parsing fails
+            end
+            # Look for the strong parameter method (e.g., page_params, user_params, etc.)
+            param_method = "#{controller.singularize}_params"
+            if controller_class.private_method_defined?(param_method.to_sym)
+              source_location = controller_class.instance_method(param_method.to_sym).source_location
+              if source_location
+                file_path, line_number = source_location
+                file_lines = File.readlines(file_path)
+                method_lines = []
+                current_line = line_number - 1
+                while current_line < file_lines.length
+                  line = file_lines[current_line].strip
+                  method_lines << line
+                  break if line.include?('end') && !line.include?('permit')
+                  current_line += 1
+                end
+                method_source = method_lines.join(' ')
+                if match = method_source.match(/\.permit\((.*?)\)/)
+                  permit_content = match[1]
+                  strong_params = permit_content.scan(/:(\w+)/).flatten
+                end
+              end
+            end
+            # Also check for any additional params the action might accept
+            additional_params = []
+            case action
+            when 'update', 'create'
+              if controller == 'pages' && action == 'update'
+                additional_params << 'message'
+              end
+            end
+            all_params = (path_params + strong_params + additional_params).uniq
+          else
+            all_params = path_params
+          end
+
+          xml = <<~XML
+            <route>
+              <name>#{route_str}</name>
+              <verb>#{verb}</verb>
+              <path>#{path}</path>
+              <path_params>#{path_params.join(', ')}</path_params>
+              <accepted_params>#{all_params.join(', ')}</accepted_params>
+              <strong_params>#{strong_params.join(', ')}</strong_params>
+              <description>#{yard_metadata[:description]}</description>
+              <tool_description>#{yard_metadata[:tool_description]}</tool_description>
+              <example>#{yard_metadata[:example]}</example>
+              <params>#{yard_metadata[:params]}</params>
+            </route>
+          XML
+
+          xml_routes += xml
+        end
+      end
+      xml_routes
+    end
+  end
+end

data/lib/llama_bot_rails/version.rb

@@ -1,3 +1,3 @@
 module LlamaBotRails
-  VERSION = "0.1.13"
+  VERSION = "0.1.14"
 end

data/lib/llama_bot_rails.rb

@@ -5,6 +5,7 @@ require "llama_bot_rails/llama_bot"
 require "llama_bot_rails/agent_state_builder"
 require "llama_bot_rails/controller_extensions"
 require "llama_bot_rails/agent_auth"
+require "llama_bot_rails/route_helper"
 
 module LlamaBotRails
   # ------------------------------------------------------------------
@@ -74,4 +75,4 @@ module LlamaBotRails
   # Bridge to backend service
   # ------------------------------------------------------------------
   def self.send_agent_message(params) = LlamaBot.send_agent_message(params)
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llama_bot_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.14
 platform: ruby
 authors:
 - Kody Kendall
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-16 00:00:00.000000000 Z
+date: 2025-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -151,11 +151,13 @@ files:
 - lib/generators/llama_bot_rails/install/templates/agent_state_builder.rb.erb
 - lib/llama_bot_rails.rb
 - lib/llama_bot_rails/agent_auth.rb
+- lib/llama_bot_rails/agent_auth_2.rb
 - lib/llama_bot_rails/agent_state_builder.rb
 - lib/llama_bot_rails/controller_extensions.rb
 - lib/llama_bot_rails/engine.rb
 - lib/llama_bot_rails/llama_bot.rb
 - lib/llama_bot_rails/railtie.rb
+- lib/llama_bot_rails/route_helper.rb
 - lib/llama_bot_rails/tools/rails_console_tool.rb
 - lib/llama_bot_rails/version.rb
 - lib/tasks/llama_bot_rails_tasks.rake