language-operator 0.1.70 → 0.1.71

data/lib/language_operator/agent/metadata_collector.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require_relative '../loggable'
+
+module LanguageOperator
+  module Agent
+    # Agent Metadata Collector
+    #
+    # Collects runtime and configuration metadata about an agent for use in
+    # persona-driven system prompts and conversation context.
+    #
+    # Provides information about:
+    # - Agent identity (name, description, persona)
+    # - Runtime environment (cluster, namespace, mode)
+    # - Operational state (uptime, workspace, status)
+    # - Configuration details (capabilities, constraints)
+    #
+    # @example
+    #   collector = MetadataCollector.new(agent)
+    #   metadata = collector.collect
+    #   puts metadata[:identity][:name]  # => "my-agent"
+    #   puts metadata[:runtime][:uptime] # => "2h 15m"
+    class MetadataCollector
+      include LanguageOperator::Loggable
+
+      attr_reader :agent, :start_time
+
+      # Initialize metadata collector
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      def initialize(agent)
+        @agent = agent
+        @start_time = Time.now
+        @logger = logger
+      end
+
+      # Collect all available metadata
+      #
+      # @return [Hash] Complete metadata structure
+      def collect
+        {
+          identity: collect_identity,
+          runtime: collect_runtime,
+          environment: collect_environment,
+          operational: collect_operational,
+          capabilities: collect_capabilities
+        }
+      end
+
+      # Collect basic identity information
+      #
+      # @return [Hash] Identity metadata
+      def collect_identity
+        config = @agent.config || {}
+        agent_config = config.dig('agent') || {}
+
+        {
+          name: ENV.fetch('AGENT_NAME', agent_config['name'] || 'unknown'),
+          description: agent_config['instructions'] || agent_config['description'] || 'AI Agent',
+          persona: agent_config['persona'] || ENV.fetch('PERSONA_NAME', nil),
+          mode: @agent.mode || 'unknown',
+          version: LanguageOperator::VERSION
+        }
+      end
+
+      # Collect runtime environment information
+      #
+      # @return [Hash] Runtime metadata
+      def collect_runtime
+        {
+          uptime: calculate_uptime,
+          started_at: @start_time.iso8601,
+          process_id: Process.pid,
+          workspace_available: @agent.workspace_available?,
+          mcp_servers_connected: @agent.respond_to?(:servers_info) ? @agent.servers_info.length : 0
+        }
+      end
+
+      # Collect deployment environment information
+      #
+      # @return [Hash] Environment metadata
+      def collect_environment
+        {
+          cluster: ENV.fetch('AGENT_CLUSTER', nil),
+          namespace: ENV.fetch('AGENT_NAMESPACE', ENV.fetch('KUBERNETES_NAMESPACE', nil)),
+          workspace_path: @agent.workspace_path,
+          kubernetes_enabled: !ENV.fetch('KUBERNETES_SERVICE_HOST', nil).nil?,
+          telemetry_enabled: !ENV.fetch('OTEL_EXPORTER_OTLP_ENDPOINT', nil).nil?
+        }
+      end
+
+      # Collect operational state information
+      #
+      # @return [Hash] Operational metadata
+      def collect_operational
+        status = determine_agent_status
+
+        {
+          status: status,
+          ready: status == 'ready',
+          mode: @agent.mode,
+          workspace: {
+            path: @agent.workspace_path,
+            available: @agent.workspace_available?,
+            writable: workspace_writable?
+          }
+        }
+      end
+
+      # Collect agent capabilities and constraints
+      #
+      # @return [Hash] Capabilities metadata
+      def collect_capabilities
+        config = @agent.config || {}
+        
+        # Extract MCP server tools if available
+        tools = []
+        if @agent.respond_to?(:servers_info)
+          @agent.servers_info.each do |server|
+            tools << {
+              server: server[:name],
+              tool_count: server[:tool_count] || 0
+            }
+          end
+        end
+
+        # Extract constraints if configured
+        constraints = config.dig('constraints') || {}
+
+        {
+          tools: tools,
+          total_tools: tools.sum { |t| t[:tool_count] },
+          constraints: constraints.empty? ? nil : constraints,
+          llm_provider: config.dig('llm', 'provider') || ENV.fetch('LLM_PROVIDER', 'unknown'),
+          llm_model: config.dig('llm', 'model') || ENV.fetch('MODEL', 'unknown')
+        }
+      end
+
+      # Get formatted summary suitable for system prompts
+      #
+      # @return [Hash] Formatted summary for prompt injection
+      def summary_for_prompt
+        metadata = collect
+        identity = metadata[:identity]
+        runtime = metadata[:runtime]
+        environment = metadata[:environment]
+        operational = metadata[:operational]
+        capabilities = metadata[:capabilities]
+
+        {
+          agent_name: identity[:name],
+          agent_description: identity[:description],
+          agent_mode: identity[:mode],
+          uptime: runtime[:uptime],
+          cluster: environment[:cluster],
+          namespace: environment[:namespace],
+          status: operational[:status],
+          workspace_available: operational[:ready],
+          tool_count: capabilities[:total_tools],
+          llm_model: capabilities[:llm_model]
+        }
+      end
+
+      private
+
+      def logger_component
+        'Agent::MetadataCollector'
+      end
+
+      # Calculate human-readable uptime
+      #
+      # @return [String] Formatted uptime string
+      def calculate_uptime
+        seconds = Time.now - @start_time
+        return 'just started' if seconds < 60
+
+        minutes = (seconds / 60).floor
+        hours = (minutes / 60).floor
+        days = (hours / 24).floor
+
+        if days > 0
+          "#{days}d #{hours % 24}h #{minutes % 60}m"
+        elsif hours > 0
+          "#{hours}h #{minutes % 60}m"
+        else
+          "#{minutes}m"
+        end
+      end
+
+      # Determine current agent status
+      #
+      # @return [String] Status string
+      def determine_agent_status
+        return 'not_ready' unless @agent.workspace_available?
+        return 'starting' if calculate_uptime == 'just started'
+        
+        # Check if agent is connected and functional
+        if @agent.respond_to?(:servers_info) && @agent.servers_info.any?
+          'ready'
+        elsif @agent.respond_to?(:servers_info) && @agent.servers_info.empty?
+          'ready_no_tools'
+        else
+          'ready'
+        end
+      end
+
+      # Check if workspace is writable
+      #
+      # @return [Boolean] True if workspace is writable
+      def workspace_writable?
+        return false unless @agent.workspace_available?
+        
+        test_file = File.join(@agent.workspace_path, '.write_test')
+        File.write(test_file, 'test')
+        File.delete(test_file)
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

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
@@ -444,7 +469,7 @@ module LanguageOperator
           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,
@@ -480,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