language-operator 0.1.70 → 0.1.80

data/lib/language_operator/agent/execution_state.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Agent
+    # Execution State Manager
+    #
+    # Manages the execution state of agents to prevent concurrent executions.
+    # Thread-safe implementation ensures only one execution runs at a time.
+    #
+    # @example Check if execution is running
+    #   state = ExecutionState.new
+    #   state.running? # => false
+    #
+    # @example Start an execution
+    #   state.start_execution('exec-123')
+    #   state.running? # => true
+    class ExecutionState
+      attr_reader :current_execution_id, :started_at, :status
+
+      # Initialize a new execution state
+      def initialize
+        @mutex = Mutex.new
+        @current_execution_id = nil
+        @started_at = nil
+        @status = :idle # :idle, :running, :completed, :failed
+      end
+
+      # Start a new execution
+      #
+      # @param execution_id [String] Unique identifier for the execution
+      # @raise [ExecutionInProgressError] if an execution is already running
+      # @return [void]
+      def start_execution(execution_id)
+        @mutex.synchronize do
+          if @status == :running
+            raise ExecutionInProgressError,
+                  "Execution #{@current_execution_id} already running"
+          end
+
+          @current_execution_id = execution_id
+          @started_at = Time.now
+          @status = :running
+        end
+      end
+
+      # Mark execution as completed
+      #
+      # @param result [Object] Optional execution result
+      # @return [Object] The result passed in
+      def complete_execution(result = nil)
+        @mutex.synchronize do
+          @status = :completed
+          result
+        end
+      end
+
+      # Mark execution as failed
+      #
+      # @param error [StandardError] The error that caused the failure
+      # @return [void]
+      def fail_execution(error)
+        @mutex.synchronize do
+          @status = :failed
+          @last_error = error
+        end
+      end
+
+      # Check if an execution is currently running
+      #
+      # @return [Boolean] true if execution is in progress
+      def running?
+        @mutex.synchronize { @status == :running }
+      end
+
+      # Get current execution information
+      #
+      # @return [Hash] Current execution state details
+      def current_info
+        @mutex.synchronize do
+          {
+            status: @status,
+            execution_id: @current_execution_id,
+            started_at: @started_at
+          }
+        end
+      end
+    end
+
+    # Error raised when attempting to start an execution while one is already running
+    class ExecutionInProgressError < StandardError; end
+  end
+end

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