language-operator 0.1.58 → 0.1.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afc74193530a3f556debc6b31b0a43769da67eaf9c956d0a7b4f17477792bf94
-  data.tar.gz: ffc401b931b0b3bd427c92a36847986442b738f2508acd1206547aa4d14c92eb
+  metadata.gz: 614dadae712dd0b6c1b72314497c73cdbcba8aa247a63cf3d01dbd789b0becaf
+  data.tar.gz: 72ad29bec20d5fdc6da1f235cd054617567c2516522e1a45bbd52f09c15bdb65
 SHA512:
-  metadata.gz: 5079fbb3621d2e3d0f00a9381bc7b6fa09c3e28ae029d3e6cde4b7e0ac42643c7881953dd66549f0379414c0a74053dfed301e832812d82902d0de553f791158
-  data.tar.gz: f24aea2d8cb473e7e9633fe713e663f637391c258695eacdd091b94dc12b206606408162f1d3cf3ae60484aa8097177bd4a858d392b132e07f6aaafadf63f35a
+  metadata.gz: cd062a5b0420dd602f411dd30b1e6fd7aa3dd7bce77ddbf7e94af95eb6991b609f57aa797c59f519150e518e89ba0839b43ca5be9a216a576b26ad9bb3b05ba0
+  data.tar.gz: cfdaa40cc2ced23bd59343b6c995499e9c718c1782f8c8c50766d1180399adc2b40c6fafd21865bb0c9130f1e9c46713639faa7985afa739f28bc47d4e66f993

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.58)
+    language-operator (0.1.61)
       faraday (~> 2.0)
       k8s-ruby (~> 0.17)
       mcp (~> 0.4)

data/components/agent/Gemfile

@@ -2,7 +2,7 @@
 
 source 'https://rubygems.org'
 
-gem 'language-operator', '~> 0.1.46'
+gem 'language-operator', '~> 0.1.59'
 
 # Agent-specific dependencies for autonomous execution
 gem 'concurrent-ruby', '~> 1.3'

data/lib/language_operator/agent/base.rb

@@ -29,6 +29,9 @@ module LanguageOperator
       def initialize(config)
         super
 
+        # Log version
+        logger.info "Language Operator v#{LanguageOperator::VERSION}"
+
         # Initialize OpenTelemetry
         LanguageOperator::Agent::Telemetry.configure
         otel_enabled = !ENV.fetch('OTEL_EXPORTER_OTLP_ENDPOINT', nil).nil?
@@ -63,6 +66,9 @@ module LanguageOperator
           else
             raise "Unknown agent mode: #{normalized_mode}"
           end
+        ensure
+          # Flush telemetry for short-lived processes (scheduled mode)
+          flush_telemetry if normalized_mode == 'scheduled'
         end
       end
 
@@ -112,6 +118,22 @@ module LanguageOperator
         @web_server = WebServer.new(self)
         @web_server.start
       end
+
+      # Flush OpenTelemetry spans to ensure they're exported before process exits
+      #
+      # Critical for short-lived processes (CronJobs) that exit quickly.
+      # BatchSpanProcessor buffers spans and exports periodically, so without
+      # explicit flushing, spans may be lost when the process terminates.
+      #
+      # @return [void]
+      def flush_telemetry
+        return unless ENV.fetch('OTEL_EXPORTER_OTLP_ENDPOINT', nil)
+
+        OpenTelemetry.tracer_provider.force_flush
+        logger.info('OpenTelemetry spans flushed to OTLP endpoint')
+      rescue StandardError => e
+        logger.warn("Failed to flush telemetry: #{e.message}")
+      end
     end
   end
 end

data/lib/language_operator/agent/task_executor.rb

@@ -117,7 +117,8 @@ module LanguageOperator
                       task: task_name,
                       type: task_type,
                       timeout: timeout,
-                      max_retries: max_retries)
+                      max_retries: max_retries,
+                      inputs: summarize_values(inputs))
 
           # Add timeout to span attributes after it's determined
           OpenTelemetry::Trace.current_span&.set_attribute('task.timeout', timeout)
@@ -214,21 +215,47 @@ module LanguageOperator
 
       # Helper method for symbolic tasks to execute tools
       #
-      # This is a simplified interface - symbolic tasks should primarily use
-      # execute_llm to leverage tools through the LLM interface, or call tools
-      # directly through the MCP client if needed.
+      # Executes an MCP tool directly through the agent's MCP clients.
       #
-      # @param tool_name [String] Name of the tool
-      # @param action [String] Tool action/method
+      # @param tool_name [Symbol, String] Name of the tool to execute
       # @param params [Hash] Tool parameters
-      # @return [Object] Tool response
-      # @note For DSL v1, tools are accessed via LLM tool calling, not direct invocation
-      def execute_tool(tool_name, action, params = {})
-        # Build prompt to use the tool via LLM
-        prompt = "Use the #{tool_name} tool to perform #{action} with parameters: #{params.inspect}"
-        execute_llm(prompt)
-        # Parse response - for now just return the text
-        # TODO: More sophisticated tool result extraction
+      # @return [Object] Tool response (parsed from tool result)
+      def execute_tool(tool_name, params = {})
+        tool_name_str = tool_name.to_s
+
+        logger.info('Tool call initiated by symbolic task',
+                    tool: tool_name_str,
+                    params: summarize_values(params))
+
+        # Find the tool across all MCP clients
+        tool = @agent.tools.find { |t| t.name == tool_name_str }
+        raise ArgumentError, "Tool '#{tool_name_str}' not found" unless tool
+
+        # Execute the tool (it's a Proc/lambda wrapped by RubyLLM)
+        result = tool.call(**params)
+
+        # Extract text from MCP Content objects
+        text_result = if result.is_a?(RubyLLM::MCP::Content)
+                        result.text
+                      elsif result.respond_to?(:map) && result.first.is_a?(RubyLLM::MCP::Content)
+                        result.map(&:text).join
+                      else
+                        result
+                      end
+
+        logger.debug('Tool call completed',
+                     tool: tool_name_str,
+                     result_preview: text_result.is_a?(String) ? text_result[0..200] : text_result.class.name)
+
+        # Try to parse JSON response if it looks like JSON
+        if text_result.is_a?(String) && (text_result.strip.start_with?('{') || text_result.strip.start_with?('['))
+          JSON.parse(text_result, symbolize_names: true)
+        else
+          text_result
+        end
+      rescue JSON::ParserError
+        # Not JSON, return as-is
+        text_result
       end
 
       # Helper method for symbolic tasks to call LLM directly
@@ -291,6 +318,25 @@ module LanguageOperator
         'Agent::TaskExecutor'
       end
 
+      # Summarize hash values for logging (truncate long strings)
+      #
+      # @param hash [Hash] Hash to summarize
+      # @return [Hash] Summarized hash with truncated values
+      def summarize_values(hash)
+        return {} unless hash.is_a?(Hash)
+
+        hash.transform_values do |v|
+          case v
+          when String
+            v.length > 100 ? "#{v[0..97]}... (#{v.length} chars)" : v
+          when Array
+            v.length > 5 ? "#{v.first(3).inspect}... (#{v.length} items)" : v.inspect
+          else
+            v.inspect
+          end
+        end
+      end
+
       # Build prompt for neural task execution
       #
       # @param task [TaskDefinition] The task definition
@@ -316,10 +362,11 @@ module LanguageOperator
         prompt += "\n"
 
         prompt += "## Response Format\n"
-        prompt += "Return ONLY valid JSON matching the output schema above.\n"
-        prompt += "Do NOT include any explanations, thinking, or text before or after the JSON.\n"
-        prompt += "Do NOT use [THINK] tags or any other markup.\n"
+        prompt += "You may include your reasoning in [THINK]...[/THINK] tags if helpful.\n"
         prompt += "Use available tools as needed to complete the task.\n"
+        prompt += "After using tools (if needed), return your final answer as valid JSON matching the output schema above.\n"
+        prompt += "Your final JSON response should come after any tool calls and thinking.\n"
+        prompt += "Do not include explanations outside of [THINK] tags - only the JSON output.\n"
 
         prompt
       end
@@ -342,8 +389,15 @@ module LanguageOperator
                       thinking_preview: thinking_blocks.first&.[](0..500))
         end
 
-        # Strip thinking tags that some models add (e.g., [THINK]...[/THINK])
-        cleaned_text = response_text.gsub(%r{\[THINK\].*?\[/THINK\]}m, '').strip
+        # Strip thinking tags that some models add (e.g., [THINK]...[/THINK] or unclosed [THINK]...)
+        # First try to strip matched pairs, then strip any remaining unclosed [THINK] content
+        logger.debug('Parsing neural response', task: task.name, response_length: response_text.length, response_start: response_text[0..100])
+
+        cleaned_text = response_text.gsub(%r{\[THINK\].*?\[/THINK\]}m, '')
+                                    .gsub(/\[THINK\].*?(?=\{|$)/m, '')
+                                    .strip
+
+        logger.debug('After stripping THINK tags', cleaned_length: cleaned_text.length, cleaned_start: cleaned_text[0..100])
 
         # Try to extract JSON from response
         # Look for JSON code blocks first
@@ -356,6 +410,8 @@ module LanguageOperator
                       json_object_match ? json_object_match[0] : cleaned_text
                     end
 
+        logger.debug('Extracted JSON text', json_length: json_text.length, json_start: json_text[0..100])
+
         # Parse JSON
         parsed = JSON.parse(json_text)
 
@@ -503,10 +559,11 @@ module LanguageOperator
                  end
 
         execution_time = Time.now - attempt_start
-        logger.debug('Task execution completed',
-                     task: task_name,
-                     attempt: attempt + 1,
-                     execution_time: execution_time.round(3))
+        logger.info('Task completed',
+                    task: task_name,
+                    attempt: attempt + 1,
+                    execution_time: execution_time.round(3),
+                    outputs: summarize_values(result))
 
         result
       rescue Timeout::Error => e

data/lib/language_operator/agent/telemetry.rb

@@ -26,29 +26,40 @@ module LanguageOperator
         #
         # @return [void]
         def configure
-          endpoint = ENV.fetch('OTEL_EXPORTER_OTLP_ENDPOINT', nil)
-          return unless endpoint
+          return unless ENV.fetch('OTEL_EXPORTER_OTLP_ENDPOINT', nil)
+
+          # Configure custom error handler for detailed logging
+          OpenTelemetry.error_handler = lambda do |exception: nil, message: nil|
+            if exception
+              warn "OpenTelemetry error: #{message} - #{exception.class}: #{exception.message}"
+              warn exception.backtrace.first(5).join("\n") if exception.backtrace
+            else
+              warn "OpenTelemetry error: #{message}"
+            end
+          end
 
+          # Initialize OpenTelemetry SDK with OTLP exporter
+          # Uses environment variables set by the operator:
+          # - OTEL_EXPORTER_OTLP_ENDPOINT: http://host:port
+          # - OTEL_SERVICE_NAME: service name
           OpenTelemetry::SDK.configure do |c|
-            c.service_name = 'language-operator-agent'
-            c.service_version = LanguageOperator::VERSION
+            c.service_name = ENV.fetch('OTEL_SERVICE_NAME', 'language-operator-agent')
 
-            # Configure resource attributes
-            c.resource = OpenTelemetry::SDK::Resources::Resource.create(
-              build_resource_attributes
-            )
+            # Add resource attributes
+            c.resource = OpenTelemetry::SDK::Resources::Resource.create(build_resource_attributes)
 
-            # Configure OTLP exporter
+            # Use OTLP HTTP exporter (reads endpoint from OTEL_EXPORTER_OTLP_ENDPOINT env var)
             c.add_span_processor(
               OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
                 OpenTelemetry::Exporter::OTLP::Exporter.new(
-                  endpoint: endpoint
+                  endpoint: "#{ENV.fetch('OTEL_EXPORTER_OTLP_ENDPOINT')}/v1/traces",
+                  headers: {}
                 )
               )
             )
           end
 
-          # Restore trace context from TRACEPARENT if present
+          # Restore trace context from TRACEPARENT if present for distributed tracing
           restore_trace_context if ENV['TRACEPARENT']
         rescue StandardError => e
           warn "Failed to configure OpenTelemetry: #{e.message}"

data/lib/language_operator/agent.rb

@@ -185,6 +185,9 @@ module LanguageOperator
 
         logger.info('Scheduled execution completed - exiting',
                     agent_name: agent_def.name)
+
+        # Flush telemetry for short-lived processes
+        agent.send(:flush_telemetry)
       when 'reactive', 'http', 'webhook'
         # Start web server with webhooks, MCP tools, and chat endpoint
         web_server = LanguageOperator::Agent::WebServer.new(agent)

data/lib/language_operator/cli/base_command.rb

@@ -20,7 +20,13 @@ module LanguageOperator
           yield
         rescue StandardError => e
           Formatters::ProgressFormatter.error("Failed to #{operation}: #{e.message}")
-          raise if ENV['DEBUG']
+
+          # Show backtrace for debugging
+          if ENV['DEBUG']
+            puts "\nBacktrace:"
+            puts e.backtrace.join("\n")
+            raise
+          end
 
           exit 1
         end