language-operator 0.1.57 → 0.1.59

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 531bb19bab7e2aaac4dbc7e430147c722e42cad7802a662a13e7aab0c29fdf3a
-  data.tar.gz: a7f7ede687479319814e519c788a57906357e76bef99b45616282c1828b7959f
+  metadata.gz: 478995080aedadd2299a94fb609d3180634abd352440b985f4eece929275bdf8
+  data.tar.gz: f0b890c5825447e6ead0ec172d9467afd59138f92350457e733cf269125e6757
 SHA512:
-  metadata.gz: a9782736dde3ec6caace204cd585de5a887c43086236325062f911e2d4271754b9a3d957c03b9ad2a8b795fcfadb6d6d5ad9f76016635182bf9ec45d7cbc1560
-  data.tar.gz: 3b1817c3d6c8ef8eff5cba64c47e7bf85edac523376a78170f16a702d82fc1a7ac0db21f7df547e99da94ad27adcd78774693faf980dceca75a957c44fd1900b
+  metadata.gz: 55a51a910de5d8580b741690ca56a2ba489cf5424892b6a9db2b31756936b8c8c11b1fe7d85b9c042cd8c56f04ab6f117af027dc28bc6cd47c6e571cbf53d7e6
+  data.tar.gz: fcf2dcad6af25f904c806d0a7b0216a7c6aa4d6d3803000096c33c350cb56050387dcb783394534226d1cc52def72628d57157dc54af60e694c229607c796147

data/Gemfile.lock

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

data/lib/language_operator/agent/base.rb

@@ -63,6 +63,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 +115,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/executor.rb

@@ -107,6 +107,17 @@ module LanguageOperator
             )
           end
 
+          # Capture thinking blocks before stripping (for observability)
+          thinking_blocks = result_text.scan(%r{\[THINK\](.*?)\[/THINK\]}m).flatten
+          if thinking_blocks.any?
+            logger.info('LLM thinking captured',
+                        event: 'llm_thinking',
+                        iteration: @iteration_count,
+                        thinking_steps: thinking_blocks.length,
+                        thinking: thinking_blocks,
+                        thinking_preview: thinking_blocks.first&.[](0..500))
+          end
+
           # Log the actual LLM response content (strip [THINK] blocks)
           cleaned_response = result_text.gsub(%r{\[THINK\].*?\[/THINK\]}m, '').strip
           response_preview = cleaned_response.length > 500 ? "#{cleaned_response[0..500]}..." : cleaned_response

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)
@@ -164,10 +165,15 @@ module LanguageOperator
           logger.debug('Calling LLM with prompt', task: task.name, prompt_preview: prompt[0..200])
           response = @agent.send_message(prompt)
 
+          # Check for tool calls and log details
+          has_tool_calls = response.respond_to?(:tool_calls) && response.tool_calls&.any?
+          tool_call_count = has_tool_calls ? response.tool_calls.length : 0
+
           logger.info('LLM response received, extracting content',
                       task: task.name,
                       response_class: response.class.name,
-                      has_tool_calls: response.respond_to?(:tool_calls) && response.tool_calls&.any?)
+                      has_tool_calls: has_tool_calls,
+                      tool_call_count: tool_call_count)
 
           response_text = response.is_a?(String) ? response : response.content
 
@@ -209,21 +215,38 @@ 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)
+
+        logger.debug('Tool call completed',
+                     tool: tool_name_str,
+                     result_preview: result.is_a?(String) ? result[0..200] : result.class.name)
+
+        # Try to parse JSON response if it looks like JSON
+        if result.is_a?(String) && (result.strip.start_with?('{') || result.strip.start_with?('['))
+          JSON.parse(result, symbolize_names: true)
+        else
+          result
+        end
+      rescue JSON::ParserError
+        # Not JSON, return as-is
+        result
       end
 
       # Helper method for symbolic tasks to call LLM directly
@@ -286,6 +309,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
@@ -311,10 +353,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
@@ -326,6 +369,17 @@ module LanguageOperator
       # @return [Hash] Parsed outputs
       # @raise [RuntimeError] If parsing fails
       def parse_neural_response(response_text, task)
+        # Capture thinking blocks before stripping (for observability)
+        thinking_blocks = response_text.scan(%r{\[THINK\](.*?)\[/THINK\]}m).flatten
+        if thinking_blocks.any?
+          logger.info('LLM thinking captured',
+                      event: 'llm_thinking',
+                      task: task.name,
+                      thinking_steps: thinking_blocks.length,
+                      thinking: thinking_blocks,
+                      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
 
@@ -487,10 +541,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