language-operator 0.1.63 → 0.1.66

data/lib/language_operator/cli/commands/cluster.rb

@@ -58,8 +58,8 @@ module LanguageOperator
             unless k8s.namespace_exists?(namespace)
               Formatters::ProgressFormatter.with_spinner("Creating namespace '#{namespace}'") do
                 k8s.create_namespace(namespace, labels: Constants::KubernetesLabels.cluster_management_labels.merge(
-                                       Constants::KubernetesLabels::CLUSTER_LABEL => name
-                                     ))
+                  Constants::KubernetesLabels::CLUSTER_LABEL => name
+                ))
               end
             end
 

data/lib/language_operator/cli/commands/status.rb

@@ -35,13 +35,13 @@ module LanguageOperator
 
               # Format cluster info using UxHelper
               logo(title: 'cluster status')
-              
+
               if cluster_resource
                 # Use actual cluster resource data
                 status = cluster_resource.dig('status', 'phase') || 'Unknown'
                 domain = cluster_resource.dig('spec', 'domain')
                 created = cluster_resource.dig('metadata', 'creationTimestamp')
-                
+
                 format_cluster_details(
                   name: current_cluster,
                   namespace: cluster_config[:namespace],

data/lib/language_operator/cli/commands/system/synthesize.rb

@@ -55,7 +55,7 @@ module LanguageOperator
               option :model, type: :string, desc: 'Model to use for synthesis (defaults to first available in cluster)'
               option :dry_run, type: :boolean, default: false, desc: 'Show prompt without calling LLM'
               option :raw, type: :boolean, default: false, desc: 'Output only the raw code without formatting'
-              
+
               def synthesize(instructions = nil)
                 handle_command_error('synthesize agent') do
                   # Read instructions from STDIN if not provided as argument

data/lib/language_operator/cli/errors/suggestions.rb

@@ -51,7 +51,7 @@ module LanguageOperator
           def agent_not_found_suggestions(context)
             suggestions = []
             suggestions << "List all agents: #{pastel.dim('aictl agent list')}"
-            suggestions << "Create a new agent: #{pastel.dim('aictl agent create \"description\"')}"
+            suggestions << "Create a new agent: #{pastel.dim('aictl agent create "description"')}"
             suggestions << "Use the wizard: #{pastel.dim('aictl agent create --wizard')}" if context[:suggest_wizard]
             suggestions
           end

data/lib/language_operator/cli/formatters/value_formatter.rb

@@ -51,7 +51,7 @@ module LanguageOperator
         #   ValueFormatter.time_ago(Time.now - 300) # => "5m ago"
         def self.time_ago(past_time)
           diff = Time.now - past_time
-          
+
           if diff < 0
             'in the future' # Edge case for clock skew
           elsif diff < SECONDS_PER_MINUTE

data/lib/language_operator/cli/helpers/ux_helper.rb

@@ -139,8 +139,7 @@ module LanguageOperator
         # @example
         #   puts highlight_ruby_code("puts 'Hello, world!'")
         def highlight_ruby_code(code_content)
-          highlighted = rouge_formatter.format(rouge_lexer.lex(code_content))
-          highlighted
+          rouge_formatter.format(rouge_lexer.lex(code_content))
         end
 
         def logo(title: nil, sparkle: false)
@@ -409,7 +408,7 @@ module LanguageOperator
         def format_resource_details(type:, name:, common_fields: {}, optional_fields: {})
           rows = { 'Name' => pastel.white.bold(name) }
           rows.merge!(common_fields)
-          
+
           optional_fields.each do |key, value|
             case key
             when 'Domain'
@@ -418,7 +417,7 @@ module LanguageOperator
               rows[key] = value if value
             end
           end
-          
+
           highlighted_box(
             title: "Language#{type}",
             rows: rows.compact

data/lib/language_operator/config.rb

@@ -191,7 +191,7 @@ module LanguageOperator
     #   Config.get_int('MAX_WORKERS', default: 4)
     def self.get_int(*keys, default: nil)
       keys.each do |key|
-        value = ENV[key.to_s]
+        value = ENV.fetch(key.to_s, nil)
         next unless value
 
         begin
@@ -220,7 +220,7 @@ module LanguageOperator
     #   Config.get_bool('USE_TLS', 'ENABLE_TLS', default: true)
     def self.get_bool(*keys, default: false)
       keys.each do |key|
-        value = ENV[key.to_s]
+        value = ENV.fetch(key.to_s, nil)
         next unless value
 
         return %w[true 1 yes on].include?(value.to_s.downcase)
@@ -240,7 +240,7 @@ module LanguageOperator
     #   Config.get_array('ALLOWED_HOSTS', separator: ',')
     def self.get_array(*keys, default: [], separator: ',')
       keys.each do |key|
-        value = ENV[key.to_s]
+        value = ENV.fetch(key.to_s, nil)
         next unless value
         next if value.empty?
 

data/lib/language_operator/constants/kubernetes_labels.rb

@@ -61,7 +61,7 @@ module LanguageOperator
         # Build a label selector string for finding tool pods
         #
         # @param tool_name [String] The tool name
-        # @return [String] Label selector string for kubectl commands  
+        # @return [String] Label selector string for kubectl commands
         def tool_selector(tool_name)
           "#{TOOL_LABEL}=#{tool_name}"
         end
@@ -77,4 +77,4 @@ module LanguageOperator
       end
     end
   end
-end
+end

data/lib/language_operator/constants.rb

@@ -60,6 +60,7 @@ module LanguageOperator
     # Kubernetes Custom Resource Definitions (CRD) kinds
     # These replace magic strings scattered across CLI commands
     RESOURCE_AGENT = 'LanguageAgent'
+    RESOURCE_AGENT_VERSION = 'LanguageAgentVersion'
     RESOURCE_MODEL = 'LanguageModel'
     RESOURCE_TOOL = 'LanguageTool'
     RESOURCE_PERSONA = 'LanguagePersona'

data/lib/language_operator/dsl/task_definition.rb

@@ -2,6 +2,7 @@
 
 require_relative '../loggable'
 require_relative '../type_coercion'
+require_relative '../agent/task_executor'
 
 module LanguageOperator
   module Dsl
@@ -148,7 +149,7 @@ module LanguageOperator
       #
       # @param params [Hash] Input parameters
       # @return [Hash] Validated and coerced parameters
-      # @raise [ArgumentError] If validation fails
+      # @raise [LanguageOperator::Agent::TaskValidationError] If validation fails
       def validate_inputs(params)
         params = params.transform_keys(&:to_sym)
         validated = {}
@@ -157,7 +158,12 @@ module LanguageOperator
           key_sym = key.to_sym
           value = params[key_sym]
 
-          raise ArgumentError, "Missing required input parameter: #{key}" if value.nil?
+          if value.nil?
+            original_error = ArgumentError.new("Missing required input parameter: #{key}")
+            raise LanguageOperator::Agent::TaskValidationError.new(@name,
+                                                                    "Missing required input parameter: #{key}",
+                                                                    original_error)
+          end
 
           validated[key_sym] = coerce_value(value, type, "input parameter '#{key}'")
         end
@@ -173,7 +179,7 @@ module LanguageOperator
       #
       # @param result [Hash] Output values
       # @return [Hash] Validated and coerced outputs
-      # @raise [ArgumentError] If validation fails
+      # @raise [LanguageOperator::Agent::TaskValidationError] If validation fails
       def validate_outputs(result)
         return result if @outputs_schema.empty? # No schema = no validation
 
@@ -184,7 +190,12 @@ module LanguageOperator
           key_sym = key.to_sym
           value = result[key_sym]
 
-          raise ArgumentError, "Missing required output field: #{key}" if value.nil?
+          if value.nil?
+            original_error = ArgumentError.new("Missing required output field: #{key}")
+            raise LanguageOperator::Agent::TaskValidationError.new(@name,
+                                                                    "Missing required output field: #{key}",
+                                                                    original_error)
+          end
 
           validated[key_sym] = coerce_value(value, type, "output field '#{key}'")
         end
@@ -275,12 +286,12 @@ module LanguageOperator
       # @param type [String] Target type
       # @param context [String] Context for error messages
       # @return [Object] Coerced value
-      # @raise [ArgumentError] If coercion fails
+      # @raise [LanguageOperator::Agent::TaskValidationError] If coercion fails
       def coerce_value(value, type, context)
         TypeCoercion.coerce(value, type)
       rescue ArgumentError => e
-        # Re-raise with context added
-        raise ArgumentError, "#{e.message} for #{context}"
+        # Re-raise as TaskValidationError with context added
+        raise LanguageOperator::Agent::TaskValidationError.new(@name, "#{e.message} for #{context}", e)
       end
 
       # Convert schema hash to JSON Schema format

data/lib/language_operator/instrumentation/task_tracer.rb

@@ -87,13 +87,19 @@ module LanguageOperator
       # @param prompt [String] The generated prompt
       # @param validated_inputs [Hash] Validated input parameters
       # @return [Hash] Span attributes
-      def neural_task_attributes(_task, prompt, validated_inputs)
+      def neural_task_attributes(task, prompt, validated_inputs)
         attributes = {
           'gen_ai.operation.name' => 'chat',
           'gen_ai.system' => determine_genai_system,
           'gen_ai.prompt.size' => prompt.bytesize
         }
 
+        # Add agent context (CRITICAL for learning system)
+        add_agent_context_attributes(attributes)
+
+        # Add task identification
+        attributes['task.name'] = task.name.to_s if task.respond_to?(:name) && task.name
+
         # Add model if available
         if @agent.respond_to?(:config) && @agent.config
           model = @agent.config.dig('llm', 'model') || @agent.config['model']
@@ -130,10 +136,19 @@ module LanguageOperator
       # @param task [TaskDefinition] The task definition
       # @return [Hash] Span attributes
       def symbolic_task_attributes(task)
-        {
+        attributes = {
           'task.execution.type' => 'symbolic',
-          'task.execution.has_block' => task.execute_block ? 'true' : 'false'
+          'task.execution.has_block' => task.execute_block ? 'true' : 'false',
+          'gen_ai.operation.name' => 'execute_task'
         }
+
+        # Add agent context (CRITICAL for learning system)
+        add_agent_context_attributes(attributes)
+
+        # Add task identification
+        attributes['task.name'] = task.name.to_s if task.respond_to?(:name) && task.name
+
+        attributes
       end
 
       # Record token usage from LLM response on span
@@ -265,6 +280,9 @@ module LanguageOperator
           'gen_ai.tool.name' => extract_tool_name(tool_call)
         }
 
+        # Add agent context (CRITICAL for learning system)
+        add_agent_context_attributes(attributes)
+
         # Add tool call ID if available
         attributes['gen_ai.tool.call.id'] = tool_call.id.to_s if tool_call.respond_to?(:id) && tool_call.id
 
@@ -341,6 +359,29 @@ module LanguageOperator
       rescue StandardError => e
         logger&.warn('Failed to record output metadata', error: e.message)
       end
+
+      # Add agent context attributes to span attributes hash
+      #
+      # Ensures all spans include agent identification required for learning system.
+      # This is redundant with resource attributes but provides explicit visibility.
+      #
+      # @param attributes [Hash] Span attributes hash to modify
+      def add_agent_context_attributes(attributes)
+        # Agent name is CRITICAL for learning controller to track executions
+        if (agent_name = ENV.fetch('AGENT_NAME', nil))
+          attributes['agent.name'] = agent_name
+        end
+
+        # Add agent mode for better traceability
+        if (agent_mode = ENV.fetch('AGENT_MODE', nil))
+          attributes['agent.mode'] = agent_mode
+        end
+
+        # Add cluster context if available
+        if (cluster_name = ENV.fetch('AGENT_CLUSTER', nil))
+          attributes['agent.cluster'] = cluster_name
+        end
+      end
     end
     # rubocop:enable Metrics/ModuleLength
   end

data/lib/language_operator/kubernetes/client.rb

@@ -3,6 +3,7 @@
 require 'k8s-ruby'
 require 'yaml'
 require_relative '../utils/secure_path'
+require_relative '../agent/event_config'
 
 module LanguageOperator
   module Kubernetes
@@ -163,6 +164,72 @@ module LanguageOperator
         create_resource(resource)
       end
 
+      # Create a Kubernetes Event
+      # @param event [Hash] Event resource hash
+      # @return [K8s::Resource] Created event resource
+      def create_event(event)
+        # Ensure proper apiVersion and kind for events
+        event = event.merge({
+                              'apiVersion' => 'v1',
+                              'kind' => 'Event'
+                            })
+        create_resource(event)
+      end
+
+      # Emit an execution event for agent task completion
+      # @param task_name [String] Name of the executed task
+      # @param success [Boolean] Whether task succeeded
+      # @param duration_ms [Float] Execution duration in milliseconds
+      # @param metadata [Hash] Additional metadata to include
+      # @return [K8s::Resource, nil] Created event resource or nil if disabled
+      def emit_execution_event(task_name, success:, duration_ms:, metadata: {})
+        # Check if events are enabled based on configuration
+        event_config = Agent::EventConfig.load
+        event_type = success ? :success : :failure
+        return nil unless Agent::EventConfig.should_emit?(event_type, event_config)
+
+        agent_name = ENV.fetch('AGENT_NAME', nil)
+        agent_namespace = ENV.fetch('AGENT_NAMESPACE', current_namespace)
+
+        return nil unless agent_name && agent_namespace
+
+        timestamp = Time.now.to_i
+        event_name = "#{agent_name}-task-#{task_name}-#{timestamp}"
+
+        event = {
+          'metadata' => {
+            'name' => event_name,
+            'namespace' => agent_namespace,
+            'labels' => {
+              'app.kubernetes.io/name' => 'language-operator',
+              'app.kubernetes.io/component' => 'agent',
+              'langop.io/agent-name' => agent_name,
+              'langop.io/task-name' => task_name.to_s
+            }
+          },
+          'involvedObject' => {
+            'kind' => 'LanguageAgent',
+            'name' => agent_name,
+            'namespace' => agent_namespace,
+            'apiVersion' => 'langop.io/v1alpha1'
+          },
+          'reason' => success ? 'TaskCompleted' : 'TaskFailed',
+          'message' => build_event_message(task_name, success, duration_ms, metadata, event_config),
+          'type' => success ? 'Normal' : 'Warning',
+          'firstTimestamp' => Time.now.utc.iso8601,
+          'lastTimestamp' => Time.now.utc.iso8601,
+          'source' => {
+            'component' => 'language-operator-agent'
+          }
+        }
+
+        create_event(event)
+      rescue StandardError => e
+        # Log error but don't fail task execution
+        warn "Failed to emit execution event: #{e.message}"
+        nil
+      end
+
       # Check if operator is installed
       def operator_installed?
         # Check if LanguageCluster CRD exists
@@ -184,6 +251,48 @@ module LanguageOperator
 
       private
 
+      # Build event message for task execution
+      # @param task_name [String] Task name
+      # @param success [Boolean] Whether task succeeded
+      # @param duration_ms [Float] Execution duration in milliseconds
+      # @param metadata [Hash] Additional metadata
+      # @param event_config [Hash] Event configuration
+      # @return [String] Formatted event message
+      def build_event_message(task_name, success, duration_ms, metadata = {}, event_config = nil)
+        event_config ||= Agent::EventConfig.load
+        content_config = Agent::EventConfig.content_config(event_config)
+
+        status = success ? 'completed successfully' : 'failed'
+        message = "Task '#{task_name}' #{status} in #{duration_ms.round(2)}ms"
+
+        # Include metadata if configured
+        if content_config[:include_task_metadata] && metadata.any?
+          # Filter metadata based on configuration
+          filtered_metadata = metadata.dup
+
+          # Remove error details if not configured to include them
+          unless content_config[:include_error_details]
+            filtered_metadata.delete('error_type')
+            filtered_metadata.delete('error_category')
+          end
+
+          if filtered_metadata.any?
+            details = filtered_metadata.map { |k, v| "#{k}: #{v}" }.join(', ')
+            message += " (#{details})"
+          end
+        end
+
+        # Truncate if configured and message is too long
+        if content_config[:truncate_long_messages] &&
+           message.length > content_config[:max_message_length]
+          max_length = content_config[:max_message_length]
+          truncated_length = message.length - max_length
+          message = message[0...max_length] + "... (truncated #{truncated_length} chars)"
+        end
+
+        message
+      end
+
       # Build singleton instance with automatic config detection
       def self.build_singleton
         if in_cluster?
@@ -266,6 +375,8 @@ module LanguageOperator
           'statefulsets'
         when 'cronjob'
           'cronjobs'
+        when 'event'
+          'events'
         else
           # Generic pluralization - add 's'
           "#{kind.downcase}s"
@@ -274,7 +385,7 @@ module LanguageOperator
 
       def default_api_version(kind)
         case kind.downcase
-        when 'languagecluster', 'languageagent', 'languagetool', 'languagemodel', 'languageclient', 'languagepersona'
+        when 'languagecluster', 'languageagent', 'languageagentversion', 'languagetool', 'languagemodel', 'languageclient', 'languagepersona'
           'langop.io/v1alpha1'
         when 'namespace', 'configmap', 'secret', 'service'
           'v1'

data/lib/language_operator/templates/schema/CHANGELOG.md

@@ -12,6 +12,34 @@ The schema version is tied directly to the gem version and follows [Semantic Ver
 
 ## Version History
 
+### 0.1.64 (2025-11-27)
+
+**Learning Status & Observability Improvements**
+
+This release enhances the learning status tracking and observability features for agents.
+
+**New Features:**
+- Added semantic OpenTelemetry attributes for learning status tracking
+- Implemented Kubernetes event emission for agent-operator communication
+- Real execution metrics from learning status ConfigMap integration
+
+**Improvements:**
+- Enhanced `aictl agent learning-status` command with color-coded boxes and better clarity
+- Changed terminology from "Runs Completed" to "Runs Processed"
+- Improved learning status display formatting with cyan highlighted boxes
+- Restructured learning status into two clear informational boxes
+
+**Bug Fixes:**
+- Handle empty string `lastExecution` in ConfigMap data
+- Fixed SigNoz Query Builder v5 select fields usage
+- Fixed K8s::Resource annotations handling in learning status command
+- Resolved hanging tests and improved test output visibility
+
+**Test Improvements:**
+- Added comprehensive aictl smoke test playbook
+- Removed obsolete learning adapter specs
+- Fixed OpenTelemetry mocking in task executor event emission test
+
 ### 0.1.34 (2025-11-14)
 
 **DSL v1: Task/Main Primitives Added**

data/lib/language_operator/templates/schema/agent_dsl_openapi.yaml

@@ -2,7 +2,7 @@
 :openapi: 3.0.3
 :info:
   :title: Language Operator Agent API
-  :version: 0.1.63
+  :version: 0.1.65
   :description: HTTP API endpoints exposed by Language Operator reactive agents
   :contact:
     :name: Language Operator

data/lib/language_operator/templates/schema/agent_dsl_schema.json

@@ -3,7 +3,7 @@
   "$id": "https://github.com/language-operator/language-operator-gem/schema/agent-dsl.json",
   "title": "Language Operator Agent DSL",
   "description": "Schema for defining autonomous AI agents using the Language Operator DSL",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/type_coercion.rb

@@ -19,7 +19,7 @@ module LanguageOperator
   # - integer: Coerces String, Integer, Float to Integer
   # - number: Coerces String, Integer, Float to Float
   # - string: Coerces any value to String via to_s
-  # - boolean: Coerces String, Boolean to Boolean (explicit values only)
+  # - boolean: Coerces String, Integer (0 or 1), Boolean to Boolean (explicit values only)
   # - array: Strict validation (no coercion)
   # - hash: Strict validation (no coercion)
   # - any: No coercion, passes through any value
@@ -32,8 +32,11 @@ module LanguageOperator
   # @example Boolean coercion
   #   TypeCoercion.coerce("true", "boolean")   # => true
   #   TypeCoercion.coerce("1", "boolean")      # => true
+  #   TypeCoercion.coerce(1, "boolean")        # => true
+  #   TypeCoercion.coerce(0, "boolean")        # => false
   #   TypeCoercion.coerce("false", "boolean")  # => false
   #   TypeCoercion.coerce("maybe", "boolean")  # raises ArgumentError
+  #   TypeCoercion.coerce(2, "boolean")        # raises ArgumentError
   #
   # @example String coercion (never fails)
   #   TypeCoercion.coerce(:symbol, "string")  # => "symbol"
@@ -213,11 +216,11 @@ module LanguageOperator
 
     # Coerce value to Boolean
     #
-    # Accepts: Boolean, String (explicit values only)
+    # Accepts: Boolean, Integer (0 or 1), String (explicit values only)
     # Coercion: Case-insensitive string matching with optimized pattern lookup
-    # Truthy: "true", "1", "yes", "t", "y"
-    # Falsy: "false", "0", "no", "f", "n"
-    # Errors: Ambiguous values (e.g., "maybe", "unknown")
+    # Truthy: "true", "1", "yes", "t", "y", 1 (integer)
+    # Falsy: "false", "0", "no", "f", "n", 0 (integer)
+    # Errors: Ambiguous values (e.g., "maybe", "unknown"), integers other than 0 or 1
     #
     # @param value [Object] Value to coerce
     # @return [Boolean] Coerced boolean
@@ -227,17 +230,28 @@ module LanguageOperator
     #   coerce_boolean(true)      # => true
     #   coerce_boolean("true")    # => true
     #   coerce_boolean("1")       # => true
+    #   coerce_boolean(1)         # => true
     #   coerce_boolean("yes")     # => true
     #   coerce_boolean(false)     # => false
     #   coerce_boolean("false")   # => false
     #   coerce_boolean("0")       # => false
+    #   coerce_boolean(0)         # => false
     #   coerce_boolean("no")      # => false
     #   coerce_boolean("maybe")   # raises ArgumentError
+    #   coerce_boolean(2)         # raises ArgumentError
     def self.coerce_boolean(value)
       # Fast path for already-correct types
       return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
 
-      # Only allow string values for coercion (not integers or other types)
+      # Handle integer 0 and 1 (common in many programming contexts)
+      if value.is_a?(Integer)
+        return true if value == 1
+        return false if value.zero?
+
+        raise ArgumentError, "Cannot coerce #{value.inspect} to boolean (only 0 and 1 are valid integers)"
+      end
+
+      # Only allow string values for coercion (not floats, symbols, or other types)
       raise ArgumentError, "Cannot coerce #{value.inspect} to boolean" unless value.is_a?(String)
 
       # Optimized pattern matching using pre-compiled arrays
@@ -308,9 +322,9 @@ module LanguageOperator
           errors: 'Never (everything has to_s)'
         },
         'boolean' => {
-          accepts: 'Boolean, String (explicit values)',
+          accepts: 'Boolean, Integer (0 or 1), String (explicit values)',
           method: 'Pattern matching (true/1/yes/t/y or false/0/no/f/n)',
-          errors: 'Ambiguous values'
+          errors: 'Ambiguous values, integers other than 0 or 1'
         },
         'array' => {
           accepts: 'Array only',

data/lib/language_operator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LanguageOperator
-  VERSION = '0.1.63'
+  VERSION = '0.1.66'
 end

data/synth/002/agent.rb

@@ -1,22 +1,33 @@
-# frozen_string_literal: true
-
 require 'language_operator'
 
-agent 'test-agent' do
-  description 'Tell a fortune every 10 minutes'
+agent "s002" do
+  description "Tell me a fortune every 10 minutes"
+
   mode :scheduled
-  schedule '*/10 * * * *'
+  schedule "*/10 * * * *"
+
+  task :generate_fortune,
+    instructions: "Generate a short, positive fortune message. Keep it under 100 words. Make it inspiring and uplifting.",
+    inputs: {},
+    outputs: { fortune: 'string' }
 
-  task :tell_fortune,
-       instructions: 'Generate a random fortune message',
-       inputs: {},
-       outputs: { fortune: 'string' }
+  task :format_output,
+    instructions: "Format the fortune message into a readable output string with a title 'Your Fortune:'",
+    inputs: { fortune: 'string' },
+    outputs: { message: 'string' }
+
+  main do |inputs|
+    fortune = execute_task(:generate_fortune)
+    output = execute_task(:format_output, inputs: fortune)
+    output
+  end
 
-  main do |_inputs|
-    execute_task(:tell_fortune)
+  constraints do
+    max_iterations 999999
+    timeout "10m"
   end
 
   output do |outputs|
-    puts outputs[:fortune]
+    puts outputs[:message]
   end
 end