language-operator 0.1.59 → 0.1.61

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 478995080aedadd2299a94fb609d3180634abd352440b985f4eece929275bdf8
-  data.tar.gz: f0b890c5825447e6ead0ec172d9467afd59138f92350457e733cf269125e6757
+  metadata.gz: 614dadae712dd0b6c1b72314497c73cdbcba8aa247a63cf3d01dbd789b0becaf
+  data.tar.gz: 72ad29bec20d5fdc6da1f235cd054617567c2516522e1a45bbd52f09c15bdb65
 SHA512:
-  metadata.gz: 55a51a910de5d8580b741690ca56a2ba489cf5424892b6a9db2b31756936b8c8c11b1fe7d85b9c042cd8c56f04ab6f117af027dc28bc6cd47c6e571cbf53d7e6
-  data.tar.gz: fcf2dcad6af25f904c806d0a7b0216a7c6aa4d6d3803000096c33c350cb56050387dcb783394534226d1cc52def72628d57157dc54af60e694c229607c796147
+  metadata.gz: cd062a5b0420dd602f411dd30b1e6fd7aa3dd7bce77ddbf7e94af95eb6991b609f57aa797c59f519150e518e89ba0839b43ca5be9a216a576b26ad9bb3b05ba0
+  data.tar.gz: cfdaa40cc2ced23bd59343b6c995499e9c718c1782f8c8c50766d1180399adc2b40c6fafd21865bb0c9130f1e9c46713639faa7985afa739f28bc47d4e66f993

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.59)
+    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?

data/lib/language_operator/agent/task_executor.rb

@@ -234,19 +234,28 @@ module LanguageOperator
         # 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: result.is_a?(String) ? result[0..200] : result.class.name)
+                     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 result.is_a?(String) && (result.strip.start_with?('{') || result.strip.start_with?('['))
-          JSON.parse(result, symbolize_names: true)
+        if text_result.is_a?(String) && (text_result.strip.start_with?('{') || text_result.strip.start_with?('['))
+          JSON.parse(text_result, symbolize_names: true)
         else
-          result
+          text_result
         end
       rescue JSON::ParserError
         # Not JSON, return as-is
-        result
+        text_result
       end
 
       # Helper method for symbolic tasks to call LLM directly
@@ -380,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
@@ -394,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)
 

data/lib/language_operator/client/base.rb

@@ -215,14 +215,16 @@ module LanguageOperator
           tracer.in_span("execute_tool.#{tool_name}", attributes: {
                            'gen_ai.operation.name' => 'execute_tool',
                            'gen_ai.tool.name' => tool_name,
+                           'gen_ai.tool.call.arguments' => arguments.to_json[0..1000],
                            'gen_ai.tool.call.arguments.size' => arguments.to_json.bytesize
                          }) do |span|
             # Execute the original tool
             result = original_tool.call(arguments)
 
-            # Record the result size
+            # Record the result (truncated for telemetry)
             result_str = result.is_a?(String) ? result : result.to_json
             span.set_attribute('gen_ai.tool.call.result.size', result_str.bytesize)
+            span.set_attribute('gen_ai.tool.call.result', result_str[0..2000])
 
             result
           rescue StandardError => e

data/lib/language_operator/dsl/task_definition.rb

@@ -229,15 +229,16 @@ module LanguageOperator
       # Execute symbolic implementation
       #
       # @param inputs [Hash] Validated inputs
-      # @param context [Object, nil] Execution context
+      # @param context [Object, nil] Execution context (TaskExecutor)
       # @return [Hash] Result from execute block
       def execute_symbolic(inputs, context)
-        if @execute_block.arity == 1
-          @execute_block.call(inputs)
-        elsif @execute_block.arity == 2
-          @execute_block.call(inputs, context)
+        if context
+          # Execute block in context's scope to make helper methods available
+          # (execute_tool, execute_task, execute_llm, etc.)
+          context.instance_exec(inputs, &@execute_block)
         else
-          @execute_block.call
+          # Fallback for standalone execution without context
+          @execute_block.call(inputs)
         end
       end
 

data/lib/language_operator/learning/adapters/base_adapter.rb

@@ -125,7 +125,9 @@ module LanguageOperator
             .map do |tool_span|
               {
                 tool_name: tool_span.dig(:attributes, 'gen_ai.tool.name'),
+                arguments: tool_span.dig(:attributes, 'gen_ai.tool.call.arguments'),
                 arguments_size: tool_span.dig(:attributes, 'gen_ai.tool.call.arguments.size'),
+                result: tool_span.dig(:attributes, 'gen_ai.tool.call.result'),
                 result_size: tool_span.dig(:attributes, 'gen_ai.tool.call.result.size')
               }
             end

data/lib/language_operator/learning/adapters/jaeger_adapter.rb

@@ -108,7 +108,10 @@ module LanguageOperator
           params[:service] = extract_service_name(filter)
 
           # Add tag filters
-          params[:tags] = { 'task.name' => filter[:task_name] }.to_json if filter[:task_name]
+          tags = {}
+          tags['task.name'] = filter[:task_name] if filter[:task_name]
+          tags['agent.name'] = filter[:agent_name] if filter[:agent_name]
+          params[:tags] = tags.to_json unless tags.empty?
 
           uri = URI.join(@endpoint, SEARCH_PATH)
           uri.query = URI.encode_www_form(params)

data/lib/language_operator/learning/adapters/signoz_adapter.rb

@@ -216,6 +216,9 @@ module LanguageOperator
           # Filter by task name (attribute name should NOT be quoted)
           expressions << "task.name = '#{filter[:task_name]}'" if filter[:task_name]
 
+          # Filter by agent name
+          expressions << "agent.name = '#{filter[:agent_name]}'" if filter[:agent_name]
+
           # Additional attribute filters
           if filter[:attributes].is_a?(Hash)
             filter[:attributes].each do |key, value|

data/lib/language_operator/learning/adapters/tempo_adapter.rb

@@ -76,6 +76,9 @@ module LanguageOperator
           # Filter by task name
           conditions << "span.\"task.name\" = \"#{escape_traceql_value(filter[:task_name])}\"" if filter[:task_name]
 
+          # Filter by agent name
+          conditions << "span.\"agent.name\" = \"#{escape_traceql_value(filter[:agent_name])}\"" if filter[:agent_name]
+
           # Additional attribute filters
           if filter[:attributes].is_a?(Hash)
             filter[:attributes].each do |key, value|

data/lib/language_operator/learning/optimizer.rb

@@ -74,6 +74,7 @@ module LanguageOperator
         neural_tasks.each do |task|
           analysis = @trace_analyzer.analyze_patterns(
             task_name: task[:name],
+            agent_name: @agent_name,
             min_executions: min_executions,
             consistency_threshold: min_consistency,
             time_range: time_range
@@ -108,10 +109,10 @@ module LanguageOperator
         task_def = find_task_definition(task_name)
         raise ArgumentError, "Task '#{task_name}' not found" unless task_def
 
-        analysis = @trace_analyzer.analyze_patterns(task_name: task_name)
+        analysis = @trace_analyzer.analyze_patterns(task_name: task_name, agent_name: @agent_name)
         raise ArgumentError, "No execution data found for task '#{task_name}'" unless analysis
 
-        traces = @trace_analyzer.query_task_traces(task_name: task_name, limit: 20)
+        traces = @trace_analyzer.query_task_traces(task_name: task_name, agent_name: @agent_name, limit: 20)
         detection_result = @pattern_detector.detect_pattern(analysis_result: analysis) unless use_synthesis
 
         return propose_via_synthesis(task_name, task_def, analysis, traces) if should_use_synthesis?(use_synthesis, detection_result)

data/lib/language_operator/learning/task_synthesizer.rb

@@ -38,7 +38,7 @@ module LanguageOperator
       def initialize(llm_client:, validator:, logger: nil)
         @llm_client = llm_client
         @validator = validator
-        @logger = logger || ::Logger.new($stdout, level: ::Logger::WARN)
+        @logger = logger || ::Logger.new($stdout, level: ::Logger::INFO)
       end
 
       # Synthesize deterministic code for a task
@@ -59,7 +59,7 @@ module LanguageOperator
           common_pattern: common_pattern
         )
 
-        @logger.debug("Task synthesis prompt:\n#{prompt}")
+        @logger.info("Task synthesis prompt:\n#{prompt}")
 
         # Call LLM
         response = call_llm(prompt)
@@ -164,16 +164,43 @@ module LanguageOperator
         return '(no traces available)' if traces.empty?
 
         traces.first(10).each_with_index.map do |trace, idx|
-          tool_sequence = trace[:tool_calls]&.map { |tc| tc[:tool_name] }&.join(' → ') || '(no tools)'
-          duration = trace[:duration_ms]&.round(1) || 'unknown'
-          inputs_summary = trace[:inputs]&.keys&.join(', ') || 'none'
-
-          <<~TRACE
-            ### Execution #{idx + 1}
-            - **Tool Sequence:** #{tool_sequence}
-            - **Duration:** #{duration}ms
-            - **Inputs:** #{inputs_summary}
-          TRACE
+          format_single_trace(trace, idx)
+        end.join("\n")
+      end
+
+      # Format a single trace execution
+      #
+      # @param trace [Hash] Single trace data
+      # @param idx [Integer] Trace index
+      # @return [String] Formatted trace
+      def format_single_trace(trace, idx)
+        tool_sequence = trace[:tool_calls]&.map { |tc| tc[:tool_name] }&.join(' → ') || '(no tools)'
+        duration = trace[:duration_ms]&.round(1) || 'unknown'
+        inputs_summary = trace[:inputs]&.keys&.join(', ') || 'none'
+        tool_details = format_tool_calls(trace[:tool_calls])
+
+        <<~TRACE
+          ### Execution #{idx + 1}
+          - **Tool Sequence:** #{tool_sequence}
+          - **Duration:** #{duration}ms
+          - **Inputs:** #{inputs_summary}
+          - **Tool Calls:**
+          #{tool_details}
+        TRACE
+      end
+
+      # Format tool call details
+      #
+      # @param tool_calls [Array<Hash>, nil] Tool call data
+      # @return [String] Formatted tool calls
+      def format_tool_calls(tool_calls)
+        return '  (no tool calls)' unless tool_calls&.any?
+
+        tool_calls.map do |tc|
+          details = "  - #{tc[:tool_name]}"
+          details += "\n    Args: #{tc[:arguments]}" if tc[:arguments]
+          details += "\n    Result: #{tc[:result]}" if tc[:result]
+          details
         end.join("\n")
       end
 

data/lib/language_operator/learning/trace_analyzer.rb

@@ -60,10 +60,11 @@ module LanguageOperator
       # Query task execution traces from backend
       #
       # @param task_name [String] Name of task to query
+      # @param agent_name [String, nil] Optional agent name to filter by
       # @param limit [Integer] Maximum number of traces to return
       # @param time_range [Integer, Range<Time>] Time range in seconds or explicit range
       # @return [Array<Hash>] Task execution data
-      def query_task_traces(task_name:, limit: 100, time_range: DEFAULT_TIME_RANGE)
+      def query_task_traces(task_name:, agent_name: nil, limit: 100, time_range: DEFAULT_TIME_RANGE)
         unless available?
           @logger.warn('No OTLP backend available, learning disabled')
           return []
@@ -71,8 +72,11 @@ module LanguageOperator
 
         range = normalize_time_range(time_range)
 
+        filter = { task_name: task_name }
+        filter[:agent_name] = agent_name if agent_name
+
         spans = @adapter.query_spans(
-          filter: { task_name: task_name },
+          filter: filter,
           time_range: range,
           limit: limit
         )
@@ -90,13 +94,14 @@ module LanguageOperator
       # learned and converted to a symbolic implementation.
       #
       # @param task_name [String] Name of task to analyze
+      # @param agent_name [String, nil] Optional agent name to filter by
       # @param min_executions [Integer] Minimum executions required for analysis
       # @param consistency_threshold [Float] Required consistency (0.0-1.0)
       # @param time_range [Integer, Range<Time>, nil] Time range for query (seconds or explicit range)
       # @return [Hash, nil] Analysis results or nil if insufficient data
-      def analyze_patterns(task_name:, min_executions: 10, consistency_threshold: DEFAULT_CONSISTENCY_THRESHOLD,
+      def analyze_patterns(task_name:, agent_name: nil, min_executions: 10, consistency_threshold: DEFAULT_CONSISTENCY_THRESHOLD,
                            time_range: nil)
-        executions = query_task_traces(task_name: task_name, limit: 1000, time_range: time_range || DEFAULT_TIME_RANGE)
+        executions = query_task_traces(task_name: task_name, agent_name: agent_name, limit: 1000, time_range: time_range || DEFAULT_TIME_RANGE)
 
         if executions.empty?
           @logger.info("No executions found for task '#{task_name}'")

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

data/lib/language_operator/templates/task_synthesis.tmpl

@@ -86,12 +86,13 @@ Respond with valid JSON:
        instructions: "Keep the original instructions for documentation",
        inputs: { ... },
        outputs: { ... } do |inputs|
-    # Your code here
-    execute_tool(:tool_name, { arg: value })
+    # Helper methods available: execute_tool, execute_task, execute_llm
+    result = execute_tool(:tool_name, { arg: value })
     { output_key: result }
   end
   ```
-- Use `execute_tool(:tool_name, { arg: value })` for tool calls
+- Use `execute_tool(:tool_name, { arg: value })` for MCP tool calls
+- Use `execute_task(:task_name, inputs: { ... })` to call other tasks
 - Access inputs via the `inputs` hash parameter
 - Return a hash matching the output schema
 - Do NOT use system(), eval(), or other unsafe methods

data/lib/language_operator/version.rb

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

data/synth/003/Makefile

@@ -1,6 +1,6 @@
 .PHONY: create code logs clean
 
-AGENT := synth-003
+AGENT := s003
 AICTL := bundle exec ../../bin/aictl agent
 TOOLS := workspace
 
@@ -28,4 +28,4 @@ clean:
 
 save:
 	$(AICTL) code $(AGENT) --raw > agent.rb
-	$(AICTL) logs $(AGENT) > output.log
+	$(AICTL) logs $(AGENT) > output.log

metadata

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