language-operator 0.1.57 → 0.1.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 531bb19bab7e2aaac4dbc7e430147c722e42cad7802a662a13e7aab0c29fdf3a
-  data.tar.gz: a7f7ede687479319814e519c788a57906357e76bef99b45616282c1828b7959f
+  metadata.gz: afc74193530a3f556debc6b31b0a43769da67eaf9c956d0a7b4f17477792bf94
+  data.tar.gz: ffc401b931b0b3bd427c92a36847986442b738f2508acd1206547aa4d14c92eb
 SHA512:
-  metadata.gz: a9782736dde3ec6caace204cd585de5a887c43086236325062f911e2d4271754b9a3d957c03b9ad2a8b795fcfadb6d6d5ad9f76016635182bf9ec45d7cbc1560
-  data.tar.gz: 3b1817c3d6c8ef8eff5cba64c47e7bf85edac523376a78170f16a702d82fc1a7ac0db21f7df547e99da94ad27adcd78774693faf980dceca75a957c44fd1900b
+  metadata.gz: 5079fbb3621d2e3d0f00a9381bc7b6fa09c3e28ae029d3e6cde4b7e0ac42643c7881953dd66549f0379414c0a74053dfed301e832812d82902d0de553f791158
+  data.tar.gz: f24aea2d8cb473e7e9633fe713e663f637391c258695eacdd091b94dc12b206606408162f1d3cf3ae60484aa8097177bd4a858d392b132e07f6aaafadf63f35a

data/Gemfile.lock

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

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

@@ -164,10 +164,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
 
@@ -326,6 +331,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
 

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

@@ -44,6 +44,7 @@ module LanguageOperator
         option :persona, type: :string, desc: 'Persona to use for the agent'
         option :tools, type: :array, desc: 'Tools to make available to the agent'
         option :models, type: :array, desc: 'Models to make available to the agent'
+        option :workspace, type: :boolean, default: true, desc: 'Enable workspace for state persistence'
         option :dry_run, type: :boolean, default: false, desc: 'Preview what would be created without applying'
         option :wizard, type: :boolean, default: false, desc: 'Use interactive wizard mode'
         def create(description = nil)
@@ -98,7 +99,8 @@ module LanguageOperator
               cluster: ctx.namespace,
               persona: options[:persona],
               tools: options[:tools] || [],
-              models: models
+              models: models,
+              workspace: options[:workspace]
             )
 
             # Dry-run mode: preview without applying

data/lib/language_operator/client/mcp_connector.rb

@@ -61,6 +61,9 @@ module LanguageOperator
 
         @chat.with_tools(*all_tools) unless all_tools.empty?
 
+        # Set up callbacks to log tool invocations
+        setup_tool_callbacks
+
         logger.info('Chat session initialized', with_tools: !all_tools.empty?)
       end
 
@@ -125,6 +128,27 @@ module LanguageOperator
 
         chat_params
       end
+
+      # Set up callbacks to log tool calls and results
+      #
+      # @return [void]
+      def setup_tool_callbacks
+        @chat.on_tool_call do |tool_call|
+          logger.info('Tool call initiated by LLM',
+                      event: 'tool_call_initiated',
+                      tool_name: tool_call.name,
+                      tool_id: tool_call.id,
+                      arguments: tool_call.arguments,
+                      arguments_json: tool_call.arguments.to_json)
+        end
+
+        @chat.on_tool_result do |result|
+          logger.info('Tool call result received',
+                      event: 'tool_result_received',
+                      result: result,
+                      result_preview: result.to_s[0..500])
+        end
+      end
     end
   end
 end

data/lib/language_operator/instrumentation/task_tracer.rb

@@ -26,6 +26,7 @@ module LanguageOperator
     #   Instrumentation adds <5% overhead with default settings
     #   Overhead may increase to ~10% with full data capture enabled
     #
+    # rubocop:disable Metrics/ModuleLength
     module TaskTracer
       # Maximum length for captured data before truncation
       MAX_CAPTURED_LENGTH = 1000
@@ -169,6 +170,11 @@ module LanguageOperator
         return unless response.respond_to?(:tool_calls)
         return unless response.tool_calls&.any?
 
+        logger&.info('Tool calls detected in LLM response',
+                     event: 'tool_calls_detected',
+                     tool_call_count: response.tool_calls.length,
+                     tool_names: response.tool_calls.map { |tc| extract_tool_name(tc) })
+
         response.tool_calls.each do |tool_call|
           record_single_tool_call(tool_call, parent_span)
         end
@@ -182,11 +188,26 @@ module LanguageOperator
       # @param parent_span [OpenTelemetry::Trace::Span] Parent span
       def record_single_tool_call(tool_call, _parent_span)
         tool_name = extract_tool_name(tool_call)
+        tool_id = tool_call.respond_to?(:id) ? tool_call.id : nil
+
+        # Extract and log tool arguments
+        arguments = extract_tool_arguments(tool_call)
 
+        logger&.info('Tool invoked by LLM',
+                     event: 'tool_call_invoked',
+                     tool_name: tool_name,
+                     tool_id: tool_id,
+                     arguments: arguments,
+                     arguments_json: (arguments.is_a?(Hash) ? JSON.generate(arguments) : arguments.to_s))
+
+        start_time = Time.now
         tracer.in_span("execute_tool #{tool_name}", attributes: build_tool_call_attributes(tool_call)) do |tool_span|
           # Tool execution already completed by ruby_llm
           # Just record the metadata
-          record_tool_result(tool_call.result, tool_span) if tool_call.respond_to?(:result) && tool_call.result
+          if tool_call.respond_to?(:result) && tool_call.result
+            duration_ms = ((Time.now - start_time) * 1000).round(2)
+            record_tool_result(tool_call.result, tool_span, tool_name, tool_id, duration_ms)
+          end
         end
       rescue StandardError => e
         logger&.warn('Failed to record tool call span', error: e.message, tool: tool_name)
@@ -206,6 +227,34 @@ module LanguageOperator
         end
       end
 
+      # Extract tool arguments from tool call object
+      #
+      # @param tool_call [Object] Tool call object
+      # @return [Hash, String] Tool arguments
+      def extract_tool_arguments(tool_call)
+        if tool_call.respond_to?(:arguments)
+          args = tool_call.arguments
+          parse_json_args(args)
+        elsif tool_call.respond_to?(:function) && tool_call.function.respond_to?(:arguments)
+          args = tool_call.function.arguments
+          parse_json_args(args)
+        else
+          {}
+        end
+      end
+
+      # Parse JSON arguments safely
+      #
+      # @param args [String, Object] Arguments to parse
+      # @return [Hash, String] Parsed arguments or original
+      def parse_json_args(args)
+        return args unless args.is_a?(String)
+
+        JSON.parse(args)
+      rescue JSON::ParserError
+        args
+      end
+
       # Build attributes for tool call span
       #
       # @param tool_call [Object] Tool call object
@@ -244,13 +293,25 @@ module LanguageOperator
       #
       # @param result [Object] Tool call result
       # @param span [OpenTelemetry::Trace::Span] The span to update
-      def record_tool_result(result, span)
+      # @param tool_name [String] Tool name (for logging)
+      # @param tool_id [String] Tool call ID (for logging)
+      # @param duration_ms [Float] Execution duration in milliseconds (for logging)
+      def record_tool_result(result, span, tool_name = nil, tool_id = nil, duration_ms = nil)
         result_str = result.is_a?(String) ? result : JSON.generate(result)
         span.set_attribute('gen_ai.tool.call.result.size', result_str.bytesize)
 
         if (sanitized_result = sanitize_data(result, :tool_results))
           span.set_attribute('gen_ai.tool.call.result', sanitized_result)
         end
+
+        # Log tool execution completion
+        logger&.info('Tool execution completed',
+                     event: 'tool_call_completed',
+                     tool_name: tool_name,
+                     tool_id: tool_id,
+                     result_size: result_str.bytesize,
+                     result: sanitize_data(result, :tool_results),
+                     duration_ms: duration_ms)
       rescue StandardError => e
         logger&.warn('Failed to record tool result', error: e.message)
       end
@@ -281,5 +342,6 @@ module LanguageOperator
         logger&.warn('Failed to record output metadata', error: e.message)
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/language_operator/kubernetes/resource_builder.rb

@@ -25,7 +25,7 @@ module LanguageOperator
 
         # Build a LanguageAgent resource
         def language_agent(name, instructions:, cluster: nil, schedule: nil, persona: nil, tools: [], models: [],
-                           mode: nil, labels: {})
+                           mode: nil, workspace: true, labels: {})
           # Determine mode: reactive, scheduled, or autonomous
           spec_mode = mode || (schedule ? 'scheduled' : 'autonomous')
 
@@ -41,6 +41,8 @@ module LanguageOperator
           spec['toolRefs'] = tools.map { |t| { 'name' => t } } unless tools.empty?
           # Convert model names to modelRef objects
           spec['modelRefs'] = models.map { |m| { 'name' => m } } unless models.empty?
+          # Enable workspace by default for state persistence
+          spec['workspace'] = { 'enabled' => workspace } if workspace
 
           {
             'apiVersion' => 'langop.io/v1alpha1',

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.57
+  :version: 0.1.58
   :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.57",
+  "version": "0.1.58",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/tool_loader.rb

@@ -173,7 +173,7 @@ module LanguageOperator
     #
     # @param tool_def [LanguageOperator::Dsl::ToolDefinition] Tool definition from DSL
     # @return [Class] MCP::Tool subclass
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def self.create_mcp_tool(tool_def)
       # Capture tool name and tracer for use in the dynamic class
       tool_name = tool_def.name
@@ -213,7 +213,9 @@ module LanguageOperator
                            'tool.type' => 'custom'
                          }) do |span|
             # Execute the tool's block
-            result = @execute_block.call(params)
+            # Convert symbol keys to string keys for consistency with DSL expectations
+            string_params = params.transform_keys(&:to_s)
+            result = @execute_block.call(string_params)
 
             # Set success attribute
             span.set_attribute('tool.result', 'success')
@@ -235,6 +237,6 @@ module LanguageOperator
         end
       end
     end
-    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
   end
 end

data/lib/language_operator/version.rb

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

data/synth/003/Makefile

@@ -7,6 +7,9 @@ TOOLS := workspace
 create:
 	cat agent.txt | $(AICTL) create --name $(AGENT) --tools "$(TOOLS)"
 
+run:
+	kubectl create job --from=cronjob/$(AGENT) $(AGENT)-manual
+
 code:
 	$(AICTL) code $(AGENT)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: language-operator
 version: !ruby/object:Gem::Version
-  version: 0.1.57
+  version: 0.1.58
 platform: ruby
 authors:
 - James Ryan