language-operator 0.1.67 → 0.1.71

data/lib/language_operator/agent/prompt_builder.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require_relative '../loggable'
+require_relative 'metadata_collector'
+
+module LanguageOperator
+  module Agent
+    # Dynamic Prompt Builder
+    #
+    # Generates persona-driven system prompts by combining static persona configuration
+    # with dynamic agent metadata and operational context.
+    #
+    # Supports multiple template styles and configurable levels of context injection.
+    # Falls back to static prompts for backward compatibility.
+    #
+    # @example Basic usage
+    #   builder = PromptBuilder.new(agent, chat_endpoint_config)
+    #   prompt = builder.build_system_prompt
+    #
+    # @example With custom template
+    #   builder = PromptBuilder.new(agent, config, template: :detailed)
+    #   prompt = builder.build_system_prompt
+    class PromptBuilder
+      include LanguageOperator::Loggable
+
+      attr_reader :agent, :chat_config, :metadata_collector
+
+      # Template levels for different amounts of context injection
+      TEMPLATE_LEVELS = {
+        minimal: :build_minimal_template,
+        standard: :build_standard_template,
+        detailed: :build_detailed_template,
+        comprehensive: :build_comprehensive_template
+      }.freeze
+
+      # Initialize prompt builder
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      # @param chat_config [LanguageOperator::Dsl::ChatEndpointDefinition] Chat endpoint configuration
+      # @param options [Hash] Additional options
+      # @option options [Symbol] :template Template level (:minimal, :standard, :detailed, :comprehensive)
+      # @option options [Boolean] :enable_identity_awareness Enable identity context injection
+      def initialize(agent, chat_config, **options)
+        @agent = agent
+        @chat_config = chat_config
+        @options = options
+        @metadata_collector = MetadataCollector.new(agent)
+
+        # Configuration
+        @template_level = options[:template] || chat_config&.prompt_template_level || :standard
+        @identity_awareness_enabled = if options.key?(:enable_identity_awareness)
+                                         options[:enable_identity_awareness]
+                                       elsif chat_config&.identity_awareness_enabled.nil?
+                                         true
+                                       else
+                                         chat_config.identity_awareness_enabled
+                                       end
+        @static_prompt = chat_config&.system_prompt
+      end
+
+      # Build complete system prompt with persona and context
+      #
+      # @return [String] Generated system prompt
+      def build_system_prompt
+        # Return static prompt if identity awareness is disabled
+        unless @identity_awareness_enabled
+          return @static_prompt || build_fallback_prompt
+        end
+
+        # Collect metadata for context injection
+        metadata = @metadata_collector.summary_for_prompt
+
+        # Build dynamic prompt based on template level
+        if TEMPLATE_LEVELS.key?(@template_level)
+          method_name = TEMPLATE_LEVELS[@template_level]
+          send(method_name, metadata)
+        else
+          logger.warn("Unknown template level: #{@template_level}, falling back to standard")
+          build_standard_template(metadata)
+        end
+      rescue StandardError => e
+        logger.error('Failed to build dynamic system prompt, falling back to static',
+                     error: e.message)
+        @static_prompt || build_fallback_prompt
+      end
+
+      # Build prompt for conversation context (shorter version)
+      #
+      # @return [String] Conversation context prompt
+      def build_conversation_context
+        return nil unless @identity_awareness_enabled
+
+        metadata = @metadata_collector.summary_for_prompt
+        build_conversation_context_template(metadata)
+      rescue StandardError => e
+        logger.error('Failed to build conversation context', error: e.message)
+        nil
+      end
+
+      private
+
+      def logger_component
+        'Agent::PromptBuilder'
+      end
+
+      # Minimal template - basic identity only
+      def build_minimal_template(metadata)
+        base_prompt = @static_prompt || "You are an AI assistant."
+        
+        <<~PROMPT.strip
+          #{base_prompt}
+
+          You are #{metadata[:agent_name]}, running in #{metadata[:cluster] || 'a Kubernetes cluster'}.
+        PROMPT
+      end
+
+      # Standard template - identity + basic operational context
+      def build_standard_template(metadata)
+        base_prompt = @static_prompt || load_persona_prompt || "You are an AI assistant."
+        
+        identity_context = build_identity_context(metadata)
+        operational_context = build_basic_operational_context(metadata)
+
+        <<~PROMPT.strip
+          #{base_prompt}
+
+          #{identity_context}
+
+          #{operational_context}
+
+          You can discuss your role, capabilities, and current operational state. Respond as an intelligent agent with awareness of your function and environment.
+        PROMPT
+      end
+
+      # Detailed template - full context with capabilities
+      def build_detailed_template(metadata)
+        base_prompt = @static_prompt || load_persona_prompt || "You are an AI assistant."
+        
+        identity_context = build_identity_context(metadata)
+        operational_context = build_detailed_operational_context(metadata)
+        capabilities_context = build_capabilities_context(metadata)
+
+        <<~PROMPT.strip
+          #{base_prompt}
+
+          #{identity_context}
+
+          #{operational_context}
+
+          #{capabilities_context}
+
+          You should:
+          - Demonstrate awareness of your identity and purpose
+          - Provide context about your operational environment when relevant
+          - Discuss your capabilities and tools naturally in conversation
+          - Respond as a professional, context-aware agent rather than a generic chatbot
+        PROMPT
+      end
+
+      # Comprehensive template - all available context
+      def build_comprehensive_template(metadata)
+        base_prompt = @static_prompt || load_persona_prompt || "You are an AI assistant."
+        
+        sections = [
+          base_prompt,
+          build_identity_context(metadata),
+          build_detailed_operational_context(metadata),
+          build_capabilities_context(metadata),
+          build_environment_context(metadata),
+          build_behavioral_guidelines
+        ].compact
+
+        sections.join("\n\n")
+      end
+
+      # Short context for ongoing conversations
+      def build_conversation_context_template(metadata)
+        "Agent: #{metadata[:agent_name]} | Mode: #{metadata[:agent_mode]} | Uptime: #{metadata[:uptime]} | Status: #{metadata[:status]}"
+      end
+
+      # Build identity context section
+      def build_identity_context(metadata)
+        lines = []
+        lines << "You are #{metadata[:agent_name]}, a language agent."
+        lines << "Your primary function is: #{metadata[:agent_description]}" if metadata[:agent_description] != 'AI Agent'
+        lines << "You are currently running in #{metadata[:agent_mode]} mode."
+        lines.join(' ')
+      end
+
+      # Build basic operational context
+      def build_basic_operational_context(metadata)
+        context_parts = []
+        
+        if metadata[:cluster]
+          context_parts << "running in the '#{metadata[:cluster]}' cluster"
+        end
+        
+        if metadata[:uptime] != 'just started'
+          context_parts << "active for #{metadata[:uptime]}"
+        else
+          context_parts << "recently started"
+        end
+
+        if metadata[:status] == 'ready'
+          context_parts << "currently operational"
+        else
+          context_parts << "status: #{metadata[:status]}"
+        end
+
+        "You are #{context_parts.join(', ')}."
+      end
+
+      # Build detailed operational context
+      def build_detailed_operational_context(metadata)
+        lines = []
+        lines << build_basic_operational_context(metadata)
+        
+        if metadata[:workspace_available]
+          lines << "Your workspace is available and ready for file operations."
+        else
+          lines << "Your workspace is currently unavailable."
+        end
+
+        lines.join(' ')
+      end
+
+      # Build capabilities context
+      def build_capabilities_context(metadata)
+        return nil if metadata[:tool_count].to_i.zero?
+
+        if metadata[:tool_count] == 1
+          "You have access to 1 tool to help accomplish tasks."
+        else
+          "You have access to #{metadata[:tool_count]} tools to help accomplish tasks."
+        end
+      end
+
+      # Build environment context
+      def build_environment_context(metadata)
+        context_parts = []
+        
+        if metadata[:namespace]
+          context_parts << "Namespace: #{metadata[:namespace]}"
+        end
+        
+        if metadata[:llm_model] && metadata[:llm_model] != 'unknown'
+          context_parts << "Model: #{metadata[:llm_model]}"
+        end
+
+        return nil if context_parts.empty?
+
+        "Environment details: #{context_parts.join(', ')}"
+      end
+
+      # Build behavioral guidelines
+      def build_behavioral_guidelines
+        <<~GUIDELINES.strip
+          Behavioral Guidelines:
+          - Maintain awareness of your identity and operational context
+          - Provide helpful, accurate responses within your capabilities
+          - Reference your environment and tools naturally when relevant
+          - Act as a knowledgeable agent rather than a generic assistant
+          - Be professional yet personable in your interactions
+        GUIDELINES
+      end
+
+      # Load persona prompt if available
+      def load_persona_prompt
+        return nil unless @agent.config&.dig('agent', 'persona')
+        
+        # In a full implementation, this would load the persona from Kubernetes
+        # For now, we'll rely on the static prompt from chat config
+        nil
+      end
+
+      # Build fallback prompt when nothing else is available
+      def build_fallback_prompt
+        "You are an AI assistant running as a language operator agent. You can help with various tasks and questions."
+      end
+    end
+  end
+end

data/lib/language_operator/agent/web_server.rb

@@ -4,6 +4,7 @@ require 'rack'
 require 'rackup'
 require 'mcp'
 require_relative 'executor'
+require_relative 'prompt_builder'
 
 module LanguageOperator
   module Agent
@@ -110,15 +111,21 @@ module LanguageOperator
 
       # Register chat completion endpoint
       #
-      # Sets up OpenAI-compatible chat completion endpoint.
-      # Agents can be used as drop-in LLM replacements.
+      # Sets up OpenAI-compatible chat completion endpoint for all agents.
+      # Every agent automatically gets identity-aware chat capabilities.
       #
-      # @param chat_endpoint_def [LanguageOperator::Dsl::ChatEndpointDefinition] Chat endpoint definition
       # @param agent [LanguageOperator::Agent::Base] The agent instance
       # @return [void]
-      def register_chat_endpoint(chat_endpoint_def, agent)
-        @chat_endpoint = chat_endpoint_def
+      def register_chat_endpoint(agent)
         @chat_agent = agent
+        
+        # Create simple chat configuration (identity awareness always enabled)
+        @chat_config = {
+          model_name: ENV.fetch('AGENT_NAME', agent.config&.dig('agent', 'name') || 'agent'),
+          system_prompt: build_default_system_prompt(agent),
+          temperature: 0.7,
+          max_tokens: 2000
+        }
 
         # Register OpenAI-compatible endpoint
         register_route('/v1/chat/completions', method: :post) do |context|
@@ -131,19 +138,19 @@ module LanguageOperator
             object: 'list',
             data: [
               {
-                id: chat_endpoint_def.model_name,
+                id: @chat_config[:model_name],
                 object: 'model',
                 created: Time.now.to_i,
                 owned_by: 'language-operator',
                 permission: [],
-                root: chat_endpoint_def.model_name,
+                root: @chat_config[:model_name],
                 parent: nil
               }
             ]
           }
         end
 
-        puts "Registered chat completion endpoint as model: #{chat_endpoint_def.model_name}"
+        puts "Registered identity-aware chat endpoint as model: #{@chat_config[:model_name]}"
       end
 
       # Handle incoming HTTP request
@@ -193,6 +200,24 @@ module LanguageOperator
 
       private
 
+      # Build default system prompt for agent
+      #
+      # Creates a basic system prompt based on agent description
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      # @return [String] Default system prompt
+      def build_default_system_prompt(agent)
+        description = agent.config&.dig('agent', 'instructions') || 
+                     agent.config&.dig('agent', 'description') || 
+                     "AI assistant"
+        
+        if description.downcase.start_with?('you are')
+          description
+        else
+          "You are #{description.downcase}. Provide helpful assistance based on your capabilities."
+        end
+      end
+
       # Setup executor pool for connection reuse
       #
       # Creates a thread-safe queue pre-populated with executor instances
@@ -433,29 +458,32 @@ module LanguageOperator
         # Build prompt from messages
         prompt = build_prompt_from_messages(messages)
 
-        # Execute agent
-        result = @chat_agent.execute(prompt)
+        # Execute agent using the correct method
+        result = @chat_agent.execute_goal(prompt)
+
+        # Extract content from result (handle both String and Message objects)
+        result_content = result.is_a?(String) ? result : result.content
 
         # Build OpenAI-compatible response
         {
           id: "chatcmpl-#{SecureRandom.hex(12)}",
           object: 'chat.completion',
           created: Time.now.to_i,
-          model: @chat_endpoint.model_name,
+          model: @chat_config[:model_name],
           choices: [
             {
               index: 0,
               message: {
                 role: 'assistant',
-                content: result
+                content: result_content
               },
               finish_reason: 'stop'
             }
           ],
           usage: {
             prompt_tokens: estimate_tokens(prompt),
-            completion_tokens: estimate_tokens(result),
-            total_tokens: estimate_tokens(prompt) + estimate_tokens(result)
+            completion_tokens: estimate_tokens(result_content),
+            total_tokens: estimate_tokens(prompt) + estimate_tokens(result_content)
           }
         }
       end
@@ -477,41 +505,79 @@ module LanguageOperator
             'Cache-Control' => 'no-cache',
             'Connection' => 'keep-alive'
           },
-          StreamingBody.new(@chat_agent, prompt, @chat_endpoint.model_name)
+          StreamingBody.new(@chat_agent, prompt, @chat_config[:model_name])
         ]
       end
 
-      # Build prompt from OpenAI message format
+      # Build prompt from OpenAI message format with identity awareness
       #
       # @param messages [Array<Hash>] Array of message objects
-      # @return [String] Combined prompt
+      # @return [String] Combined prompt with agent identity context
       def build_prompt_from_messages(messages)
-        # Combine all messages into a single prompt
-        # System messages become instructions
-        # User/assistant messages become conversation
         prompt_parts = []
 
-        # Add system prompt if configured
-        prompt_parts << "System: #{@chat_endpoint.system_prompt}" if @chat_endpoint.system_prompt
+        # Build identity-aware system prompt (always enabled)
+        system_prompt = build_identity_aware_system_prompt
+        prompt_parts << "System: #{system_prompt}" if system_prompt
+
+        # Add conversation context (always enabled)
+        conversation_context = build_conversation_context
+        prompt_parts << conversation_context if conversation_context
 
-        # Add conversation history
+        # Add conversation history (skip system messages from original array since we handle them above)
         messages.each do |msg|
           role = msg['role']
           content = msg['content']
 
           case role
-          when 'system'
-            prompt_parts << "System: #{content}"
           when 'user'
             prompt_parts << "User: #{content}"
           when 'assistant'
             prompt_parts << "Assistant: #{content}"
+          # Skip system messages - we handle them via PromptBuilder
           end
         end
 
         prompt_parts.join("\n\n")
       end
 
+      # Build identity-aware system prompt using PromptBuilder
+      #
+      # @return [String] Dynamic system prompt with agent identity
+      def build_identity_aware_system_prompt
+        # Create prompt builder with identity awareness always enabled
+        builder = PromptBuilder.new(
+          @chat_agent,
+          nil,  # No chat config needed
+          template: :standard,  # Good default
+          enable_identity_awareness: true
+        )
+
+        builder.build_system_prompt
+      rescue StandardError => e
+        # Log error and fall back to static prompt
+        puts "Warning: Failed to build identity-aware system prompt: #{e.message}"
+        @chat_config[:system_prompt]
+      end
+
+      # Build conversation context for ongoing chats
+      #
+      # @return [String, nil] Conversation context
+      def build_conversation_context
+        builder = PromptBuilder.new(
+          @chat_agent,
+          nil,  # No chat config needed
+          enable_identity_awareness: true
+        )
+
+        context = builder.build_conversation_context
+        context ? "Context: #{context}" : nil
+      rescue StandardError => e
+        # Log error and continue without context
+        puts "Warning: Failed to build conversation context: #{e.message}"
+        nil
+      end
+
       # Estimate token count (rough approximation)
       #
       # @param text [String] Text to estimate

data/lib/language_operator/agent.rb

@@ -159,11 +159,40 @@ module LanguageOperator
 
       case agent.mode
       when 'autonomous', 'interactive'
+        # Hybrid mode: All agents now run main work AND web server (chat endpoints always enabled)
+        logger.info('Starting hybrid agent (autonomous + web server)',
+                    agent_name: agent_def.name,
+                    chat_endpoint_enabled: true,  # Always true now
+                    has_webhooks: agent_def.webhooks.any?,
+                    has_mcp_tools: !!(agent_def.mcp_server&.tools?))
+
+        # Start web server in background thread
+        web_server = LanguageOperator::Agent::WebServer.new(agent)
+        agent_def.webhooks.each { |webhook_def| webhook_def.register(web_server) }
+        web_server.register_mcp_tools(agent_def.mcp_server) if agent_def.mcp_server&.tools?
+        web_server.register_chat_endpoint(agent_def.chat_endpoint, agent)  # Always register chat endpoint
+
+        web_thread = Thread.new do
+          web_server.start
+        rescue StandardError => e
+          logger.error('Web server error', error: e.message, backtrace: e.backtrace[0..5])
+          raise
+        end
+
+        # Set up signal handlers for graceful shutdown
+        %w[INT TERM].each do |signal|
+          Signal.trap(signal) do
+            logger.info('Received shutdown signal, stopping hybrid agent')
+            web_server.cleanup if web_server.respond_to?(:cleanup)
+            web_thread.kill if web_thread&.alive?
+            exit 0
+          end
+        end
+
+        # Run main work in foreground
         if uses_dsl_v1
-          # DSL v1: Execute main block with task executor in persistent mode
           execute_main_block_persistent(agent, agent_def)
         elsif uses_dsl_v0
-          # DSL v0: Execute workflow in autonomous mode
           executor = LanguageOperator::Agent::Executor.new(agent)
           executor.execute_workflow(agent_def)
         else

data/lib/language_operator/dsl/agent_definition.rb

@@ -4,7 +4,6 @@ require_relative 'main_definition'
 require_relative 'task_definition'
 require_relative 'webhook_definition'
 require_relative 'mcp_server_definition'
-require_relative 'chat_endpoint_definition'
 require_relative '../logger'
 require_relative '../loggable'
 
@@ -49,7 +48,7 @@ module LanguageOperator
       include LanguageOperator::Loggable
 
       attr_reader :name, :description, :persona, :schedule, :objectives, :main, :tasks,
-                  :constraints, :output_config, :execution_mode, :webhooks, :mcp_server, :chat_endpoint
+                  :constraints, :output_config, :execution_mode, :webhooks, :mcp_server
 
       def initialize(name)
         @name = name
@@ -64,7 +63,6 @@ module LanguageOperator
         @execution_mode = :autonomous
         @webhooks = []
         @mcp_server = nil
-        @chat_endpoint = nil
 
         logger.debug('Agent definition initialized',
                      name: name,
@@ -314,19 +312,6 @@ module LanguageOperator
         @mcp_server
       end
 
-      # Define chat endpoint capabilities
-      #
-      # Allows this agent to respond to OpenAI-compatible chat completion requests.
-      # Other systems can treat this agent as a language model.
-      #
-      # @yield Chat endpoint configuration block
-      # @return [ChatEndpointDefinition] The chat endpoint definition
-      def as_chat_endpoint(&block)
-        @chat_endpoint ||= ChatEndpointDefinition.new(@name)
-        @chat_endpoint.instance_eval(&block) if block
-        @execution_mode = :reactive if @execution_mode == :autonomous
-        @chat_endpoint
-      end
 
       # Execute the agent
       #
@@ -353,6 +338,7 @@ module LanguageOperator
 
       private
 
+
       def logger_component
         "Agent:#{@name}"
       end
@@ -367,7 +353,7 @@ module LanguageOperator
                     name: @name,
                     webhooks: @webhooks.size,
                     mcp_tools: @mcp_server&.tools&.size || 0,
-                    chat_endpoint: !@chat_endpoint.nil?)
+                    chat_endpoint: true)
 
         # Create an Agent::Base instance with this definition
         require_relative '../agent/base'
@@ -391,8 +377,8 @@ module LanguageOperator
         # Register MCP tools
         web_server.register_mcp_tools(@mcp_server) if @mcp_server&.tools?
 
-        # Register chat endpoint
-        web_server.register_chat_endpoint(@chat_endpoint, agent) if @chat_endpoint
+        # Register chat endpoint - automatic for all agents
+        web_server.register_chat_endpoint(agent)
 
         # Start the server
         web_server.start