language-operator 0.1.36 → 0.1.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dab6721a2a81cadf3c5a252b082c77cbe3dc9262480355637c4971e0bde231f3
-  data.tar.gz: b11d038d3928f29fdb91e09e859e04112f4f46d846556e8582ff33ee37c074ae
+  metadata.gz: 4476732244850657fb5161189ad68010e2ffdef4f4949361786893d119f0de89
+  data.tar.gz: 5755720ffc0df24c88c5ec5ea223a4f8899c604f938422e420e878833d172de5
 SHA512:
-  metadata.gz: 1b0ec3258b68eeb7469f8e6679dfb6f691465c404bc3c2a99c9fd99156ed96bd0e06279d0100ed495f13b134128a875e57eb3d50013139c36bb9cff23edf398b
-  data.tar.gz: fcb46362bb7ef404b990ca17e061416f1da10a10d5e7c9b65188292797f8ea96b6a4f5e9d67f73587e891a225dae7d76bcb3c34500ec64b192e6d06c5d57b18b
+  metadata.gz: a4408235ba4cc775fc175f7760e0632e78457630b263690efeb3ddc772c58facfcd7b7e0780a38d33bda5c4f9d3d12b46eed0f83d43631c94f1ddfe7180be61d
+  data.tar.gz: 3ccbd9c8c91ef1d19ae467cafe3740cc84586853692cf46569d77b692b1cddf682fb21300bbb75244e71335b84a10fde768f6baff1016d18acf8b4c31a869862

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.36)
+    language-operator (0.1.38)
+      faraday (~> 2.0)
       k8s-ruby (~> 0.17)
       mcp (~> 0.4)
       opentelemetry-exporter-otlp (~> 0.27)

data/lib/language_operator/agent/executor.rb

@@ -203,40 +203,6 @@ module LanguageOperator
                     reason: 'Hit max_iterations limit')
       end
 
-      # Write output to configured destinations
-      #
-      # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
-      # @param result [RubyLLM::Message] The result to write
-      def write_output(agent_def, result)
-        return unless agent_def.output_config
-
-        content = result.is_a?(String) ? result : result.content
-
-        if (workspace_path = agent_def.output_config[:workspace])
-          full_path = File.join(@agent.workspace_path, workspace_path)
-
-          begin
-            FileUtils.mkdir_p(File.dirname(full_path))
-            File.write(full_path, content)
-            logger.info("📝 Wrote output to #{workspace_path}")
-          rescue Errno::EACCES, Errno::EPERM
-            # Permission denied - try writing to workspace root
-            fallback_path = File.join(@agent.workspace_path, 'output.txt')
-            begin
-              File.write(fallback_path, content)
-              logger.warn("Could not write to #{workspace_path}, wrote to output.txt instead")
-            rescue StandardError => e2
-              logger.warn("Could not write output to workspace: #{e2.message}")
-              logger.info("Output (first 500 chars): #{content[0..500]}")
-            end
-          end
-        end
-
-        # Future: Handle Slack, email outputs
-      rescue StandardError => e
-        logger.warn('Output writing failed', error: e.message)
-      end
-
       private
 
       def logger_component

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

@@ -198,49 +198,58 @@ module LanguageOperator
           end
         end
 
-        desc 'test-synthesis', 'Test agent synthesis from natural language instructions'
+        desc 'synthesize INSTRUCTIONS', 'Synthesize agent code from natural language instructions'
         long_desc <<-DESC
-          Test the agent synthesis process by converting natural language instructions
+          Synthesize agent code by converting natural language instructions
           into Ruby DSL code without creating an actual agent.
 
+          This command uses a LanguageModel resource from your cluster to generate
+          agent code. If --model is not specified, the first available model will
+          be auto-selected.
+
           This command helps you validate your instructions and understand how the
           synthesis engine interprets them. Use --dry-run to see the prompt that
           would be sent to the LLM, or run without it to generate actual code.
 
           Examples:
             # Test with dry-run (show prompt only)
-            aictl system test-synthesis --instructions "Monitor GitHub issues daily" --dry-run
+            aictl system synthesize "Monitor GitHub issues daily" --dry-run
+
+            # Generate code from instructions (auto-selects first available model)
+            aictl system synthesize "Send daily reports to Slack"
+
+            # Use a specific cluster model
+            aictl system synthesize "Process webhooks from GitHub" --model my-claude
 
-            # Generate code from instructions
-            aictl system test-synthesis --instructions "Send daily reports to Slack"
+            # Output raw code without formatting (useful for piping to files)
+            aictl system synthesize "Monitor logs" --raw > agent.rb
 
             # Specify custom agent name and tools
-            aictl system test-synthesis \\
-              --instructions "Process webhooks from GitHub" \\
+            aictl system synthesize "Process webhooks from GitHub" \\
               --agent-name github-processor \\
-              --tools github,slack
-
-            # Specify available models
-            aictl system test-synthesis \\
-              --instructions "Analyze logs every hour" \\
-              --models gpt-4,claude-3-5-sonnet
+              --tools github,slack \\
+              --model my-gpt4
         DESC
-        option :instructions, type: :string, required: true, desc: 'Natural language instructions for the agent'
         option :agent_name, type: :string, default: 'test-agent', desc: 'Name for the test agent'
         option :tools, type: :string, desc: 'Comma-separated list of available tools'
-        option :models, type: :string, desc: 'Comma-separated list of available models'
+        option :models, type: :string, desc: 'Comma-separated list of available models (from cluster)'
+        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'
-        def test_synthesis
-          handle_command_error('test synthesis') do
+        option :raw, type: :boolean, default: false, desc: 'Output only the raw code without formatting'
+        def synthesize(instructions)
+          handle_command_error('synthesize agent') do
+            # Select model to use for synthesis
+            selected_model = select_synthesis_model
+
             # Load synthesis template
             template_content = load_bundled_template('agent')
 
             # Detect temporal intent from instructions
-            temporal_intent = detect_temporal_intent(options[:instructions])
+            temporal_intent = detect_temporal_intent(instructions)
 
             # Prepare template data
             template_data = {
-              'Instructions' => options[:instructions],
+              'Instructions' => instructions,
               'AgentName' => options[:agent_name],
               'ToolsList' => format_tools_list(options[:tools]),
               'ModelsList' => format_models_list(options[:models]),
@@ -267,11 +276,8 @@ module LanguageOperator
               return
             end
 
-            # Call LLM to generate code
-            puts 'Generating agent code from instructions...'
-            puts
-
-            llm_response = call_llm_for_synthesis(rendered_prompt)
+            # Call LLM to generate code (no output - just do it)
+            llm_response = call_llm_for_synthesis(rendered_prompt, selected_model)
 
             # Extract Ruby code from response
             generated_code = extract_ruby_code(llm_response)
@@ -284,34 +290,19 @@ module LanguageOperator
               exit 1
             end
 
-            # Display generated code
-            puts 'Generated Code:'
-            puts '=' * 80
-            puts generated_code
-            puts '=' * 80
-            puts
-
-            # Validate generated code
-            puts 'Validating generated code...'
-            validation_result = validate_code_against_schema(generated_code)
-
-            if validation_result[:valid] && validation_result[:warnings].empty?
-              Formatters::ProgressFormatter.success('✅ Code is valid - No issues found')
-            elsif validation_result[:valid]
-              Formatters::ProgressFormatter.success('✅ Code is valid - With warnings')
-              puts
-              validation_result[:warnings].each do |warn|
-                puts "  ⚠  #{warn[:message]}"
-              end
-            else
-              Formatters::ProgressFormatter.error('❌ Code validation failed')
-              puts
-              validation_result[:errors].each do |err|
-                puts "  ✗ #{err[:message]}"
-              end
+            # Handle raw output
+            if options[:raw]
+              puts generated_code
+              return
             end
 
-            puts
+            # Display formatted code
+            require 'rouge'
+            formatter = Rouge::Formatters::Terminal256.new
+            lexer = Rouge::Lexers::Ruby.new
+            highlighted_code = formatter.format(lexer.lex(generated_code))
+
+            puts highlighted_code
           end
         end
 
@@ -449,68 +440,217 @@ module LanguageOperator
 
         # Format models list for template
         def format_models_list(models_str)
-          # If not specified, try to detect from environment
+          # If not specified, try to detect from cluster
           if models_str.nil? || models_str.strip.empty?
             models = detect_available_models
             return models.map { |model| "- #{model}" }.join("\n") unless models.empty?
 
-            return 'No models specified (configure ANTHROPIC_API_KEY or OPENAI_API_KEY)'
+            return 'No models available (run: aictl model list)'
           end
 
           models = models_str.split(',').map(&:strip)
           models.map { |model| "- #{model}" }.join("\n")
         end
 
-        # Detect available models from environment
+        # Detect available models from cluster
         def detect_available_models
-          models = []
-          models << 'claude-3-5-sonnet-20241022' if ENV['ANTHROPIC_API_KEY']
-          models << 'gpt-4-turbo' if ENV['OPENAI_API_KEY']
-          models
+          models = ctx.client.list_resources('LanguageModel', namespace: ctx.namespace)
+          models.map { |m| m.dig('metadata', 'name') }
+        rescue StandardError => e
+          Formatters::ProgressFormatter.error("Failed to list models from cluster: #{e.message}")
+          []
         end
 
-        # Call LLM to generate code from synthesis prompt
-        def call_llm_for_synthesis(prompt)
-          require 'ruby_llm'
+        # Select model to use for synthesis
+        def select_synthesis_model
+          # If --model option specified, use it
+          return options[:model] if options[:model]
+
+          # Otherwise, auto-select from available cluster models
+          available_models = detect_available_models
 
-          # Check for API keys
-          unless ENV['ANTHROPIC_API_KEY'] || ENV['OPENAI_API_KEY']
-            Formatters::ProgressFormatter.error('No LLM credentials found')
+          if available_models.empty?
+            Formatters::ProgressFormatter.error('No models available in cluster')
             puts
-            puts 'Please set one of the following environment variables:'
-            puts '  - ANTHROPIC_API_KEY (for Claude models)'
-            puts '  - OPENAI_API_KEY (for GPT models)'
+            puts 'Please create a model first:'
+            puts '  aictl model create'
+            puts
+            puts 'Or list existing models:'
+            puts '  aictl model list'
             exit 1
           end
 
-          # Prefer Anthropic if available
-          if ENV['ANTHROPIC_API_KEY']
-            provider = :anthropic
-            api_key = ENV['ANTHROPIC_API_KEY']
-            model = 'claude-3-5-sonnet-20241022'
-          else
-            provider = :openai
-            api_key = ENV.fetch('OPENAI_API_KEY', nil)
-            model = 'gpt-4-turbo'
+          # Auto-select first available model (silently)
+          available_models.first
+        end
+
+        # Get endpoint for a cluster model
+        def get_model_endpoint(model_name)
+          # For cluster models, we use the service endpoint
+          # The service is typically named the same as the model and listens on port 4000
+          "http://#{model_name}.#{ctx.namespace}.svc.cluster.local:4000/v1"
+        end
+
+        # Call LLM to generate code from synthesis prompt using cluster model
+        def call_llm_for_synthesis(prompt, model_name)
+          require 'json'
+          require 'faraday'
+
+          # Get model resource
+          model = get_resource_or_exit('LanguageModel', model_name)
+          model_id = model.dig('spec', 'modelName')
+
+          # Get the model's pod
+          pod = get_model_pod(model_name)
+          pod_name = pod.dig('metadata', 'name')
+
+          # Set up port-forward to access the model pod
+          port_forward_pid = nil
+          local_port = find_available_port
+
+          begin
+            # Start kubectl port-forward in background
+            port_forward_pid = start_port_forward(pod_name, local_port, 4000)
+
+            # Wait for port-forward to be ready
+            wait_for_port(local_port)
+
+            # Build the JSON payload for the chat completion request
+            payload = {
+              model: model_id,
+              messages: [{ role: 'user', content: prompt }],
+              max_tokens: 4000,
+              temperature: 0.3
+            }
+
+            # Make HTTP request using Faraday
+            conn = Faraday.new(url: "http://localhost:#{local_port}") do |f|
+              f.request :json
+              f.response :json
+              f.adapter Faraday.default_adapter
+              f.options.timeout = 120
+              f.options.open_timeout = 10
+            end
+
+            response = conn.post('/v1/chat/completions', payload)
+
+            # Parse response
+            result = response.body
+
+            if result['error']
+              error_msg = result['error']['message'] || result['error']
+              raise "Model error: #{error_msg}"
+            elsif !result['choices'] || result['choices'].empty?
+              raise "Unexpected response format: #{result.inspect}"
+            end
+
+            # Extract the content from the first choice
+            result.dig('choices', 0, 'message', 'content')
+          rescue Faraday::TimeoutError
+            raise 'LLM request timed out after 120 seconds'
+          rescue Faraday::ConnectionFailed => e
+            raise "Failed to connect to model: #{e.message}"
+          rescue StandardError => e
+            Formatters::ProgressFormatter.error("LLM call failed: #{e.message}")
+            puts
+            puts "Make sure the model '#{model_name}' is running: kubectl get pods -n #{ctx.namespace}"
+            exit 1
+          ensure
+            # Clean up port-forward process
+            cleanup_port_forward(port_forward_pid) if port_forward_pid
           end
+        end
+
+        # Get the pod for a model
+        def get_model_pod(model_name)
+          # Get the deployment for the model
+          deployment = ctx.client.get_resource('Deployment', model_name, ctx.namespace)
+          labels = deployment.dig('spec', 'selector', 'matchLabels')
 
-          # Create client and call LLM
-          client = RubyLLM.new(provider: provider, api_key: api_key)
-          messages = [{ role: 'user', content: prompt }]
+          raise "Deployment '#{model_name}' has no selector labels" if labels.nil?
 
-          response = client.chat(messages, model: model, max_tokens: 4000, temperature: 0.3)
+          # Convert to hash if needed
+          labels_hash = labels.respond_to?(:to_h) ? labels.to_h : labels
+          raise "Deployment '#{model_name}' has empty selector labels" if labels_hash.empty?
 
-          # Extract content from response
-          if response.is_a?(Hash) && response.key?('content')
-            response['content']
-          elsif response.is_a?(String)
-            response
-          else
-            response.to_s
+          label_selector = labels_hash.map { |k, v| "#{k}=#{v}" }.join(',')
+
+          # Find a running pod
+          pods = ctx.client.list_resources('Pod', namespace: ctx.namespace, label_selector: label_selector)
+          raise "No pods found for model '#{model_name}'" if pods.empty?
+
+          running_pod = pods.find do |pod|
+            pod.dig('status', 'phase') == 'Running' &&
+              pod.dig('status', 'conditions')&.any? { |c| c['type'] == 'Ready' && c['status'] == 'True' }
+          end
+
+          if running_pod.nil?
+            pod_phases = pods.map { |p| p.dig('status', 'phase') }.join(', ')
+            raise "No running pods found. Pod phases: #{pod_phases}"
+          end
+
+          running_pod
+        rescue K8s::Error::NotFound
+          raise "Model deployment '#{model_name}' not found"
+        end
+
+        # Find an available local port for port-forwarding
+        def find_available_port
+          require 'socket'
+
+          # Try ports in the range 14000-14999
+          (14_000..14_999).each do |port|
+            server = TCPServer.new('127.0.0.1', port)
+            server.close
+            return port
+          rescue Errno::EADDRINUSE
+            # Port in use, try next
+            next
+          end
+
+          raise 'No available ports found in range 14000-14999'
+        end
+
+        # Start kubectl port-forward in background
+        def start_port_forward(pod_name, local_port, remote_port)
+          require 'English'
+
+          cmd = "kubectl port-forward -n #{ctx.namespace} #{pod_name} #{local_port}:#{remote_port}"
+          pid = spawn(cmd, out: '/dev/null', err: '/dev/null')
+
+          # Detach so it runs in background
+          Process.detach(pid)
+
+          pid
+        end
+
+        # Wait for port-forward to be ready
+        def wait_for_port(port, max_attempts: 30)
+          require 'socket'
+
+          max_attempts.times do
+            socket = TCPSocket.new('127.0.0.1', port)
+            socket.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            sleep 0.1
+          end
+
+          raise "Port-forward to localhost:#{port} failed to become ready after #{max_attempts} attempts"
+        end
+
+        # Clean up port-forward process
+        def cleanup_port_forward(pid)
+          return unless pid
+
+          begin
+            Process.kill('TERM', pid)
+            Process.wait(pid, Process::WNOHANG)
+          rescue Errno::ESRCH
+            # Process already gone
+          rescue Errno::ECHILD
+            # Process already reaped
           end
-        rescue StandardError => e
-          Formatters::ProgressFormatter.error("LLM call failed: #{e.message}")
-          exit 1
         end
 
         # Extract Ruby code from LLM response
@@ -550,7 +690,7 @@ module LanguageOperator
         # Load bundled template from gem
         def load_bundled_template(type)
           filename = type == 'agent' ? 'agent_synthesis.tmpl' : 'persona_distillation.tmpl'
-          template_path = File.join(__dir__, '..', '..', 'templates', 'examples', filename)
+          template_path = File.join(__dir__, '..', '..', 'templates', filename)
           File.read(template_path)
         end
 

data/lib/language_operator/dsl/agent_definition.rb

@@ -60,7 +60,7 @@ module LanguageOperator
         @main = nil
         @tasks = {}
         @constraints = {}
-        @output_config = {}
+        @output_config = nil
         @execution_mode = :autonomous
         @webhooks = []
         @mcp_server = nil
@@ -223,16 +223,58 @@ module LanguageOperator
         @constraints = constraint_builder.to_h
       end
 
-      # Define output configuration
+      # Define output handler (organic function) - DSL v1
       #
-      # @yield Output configuration block
-      # @return [Hash] Current output config
-      def output(&block)
-        return @output_config if block.nil?
+      # The output is an organic function that receives the final outputs from main execution
+      # and handles them (logging, saving to workspace, notifications, etc.). Like tasks,
+      # it can be neural (instructions-based), symbolic (code block), or hybrid (both).
+      #
+      # @param options [Hash] Output configuration
+      # @option options [String] :instructions Natural language instructions (neural)
+      # @yield [outputs] Symbolic implementation block (optional)
+      # @yieldparam outputs [Hash] The outputs returned from main execution
+      # @return [TaskDefinition] The output task definition
+      #
+      # @example Neural output
+      #   output instructions: "save results to workspace as JSON"
+      #
+      # @example Symbolic output
+      #   output do |outputs|
+      #     File.write("/workspace/result.json", JSON.pretty_generate(outputs))
+      #   end
+      #
+      # @example Hybrid output
+      #   output instructions: "save results to workspace" do |outputs|
+      #     File.write("/workspace/result.json", outputs.to_json)
+      #   end
+      def output(**options, &block)
+        return @output_config if options.empty? && block.nil?
+
+        # Create a TaskDefinition for output (it's an organic function)
+        output_task = TaskDefinition.new(:output)
+
+        # Output task always receives main's outputs as inputs (type: any)
+        # No need to specify inputs - they come from main
+
+        # Configure instructions if provided (neural)
+        output_task.instructions(options[:instructions]) if options[:instructions]
+
+        # Symbolic implementation (if block provided)
+        output_task.execute(&block) if block
+
+        @output_config = output_task
+
+        task_type = if output_task.neural? && output_task.symbolic?
+                      'hybrid'
+                    elsif output_task.neural?
+                      'neural'
+                    else
+                      'symbolic'
+                    end
+
+        logger.debug('Output defined', type: task_type)
 
-        output_builder = OutputBuilder.new
-        output_builder.instance_eval(&block) if block
-        @output_config = output_builder.to_h
+        output_task
       end
 
       # Set execution mode
@@ -408,9 +450,15 @@ module LanguageOperator
 
           # If main defined, execute it; otherwise just log
           if @main
-            logger.timed('Objective main execution') do
+            outputs = logger.timed('Objective main execution') do
               @main.call({ objective: objective })
             end
+
+            # Call output handler if defined (it's an organic function)
+            if @output_config.is_a?(TaskDefinition)
+              logger.debug('Executing output handler', outputs: outputs)
+              execute_output_handler(outputs)
+            end
           else
             logger.warn('No main block defined, skipping execution')
           end
@@ -418,6 +466,29 @@ module LanguageOperator
 
         logger.info('All objectives completed', total: @objectives.size)
       end
+
+      # Execute the output handler (neural or symbolic)
+      #
+      # @param outputs [Hash] The outputs from main execution
+      def execute_output_handler(outputs)
+        # If symbolic implementation exists, use it
+        if @output_config.symbolic?
+          logger.debug('Executing symbolic output handler')
+          # execute_symbolic takes (inputs, context) - outputs are the inputs, context is nil
+          @output_config.execute_symbolic(outputs, nil)
+        elsif @output_config.neural?
+          # Neural output - would need LLM access to execute
+          # For now, just log the instruction
+          logger.info('Neural output handler',
+                      instruction: @output_config.instructions_text,
+                      outputs: outputs)
+          logger.warn('Neural output execution not yet implemented - instruction logged only')
+        end
+      rescue StandardError => e
+        logger.error('Output handler failed',
+                     error: e.message,
+                     backtrace: e.backtrace[0..5])
+      end
     end
 
     # Helper class for building constraints
@@ -485,28 +556,5 @@ module LanguageOperator
         @constraints
       end
     end
-
-    # Helper class for building output configuration
-    class OutputBuilder
-      def initialize
-        @config = {}
-      end
-
-      def workspace(path)
-        @config[:workspace] = path
-      end
-
-      def slack(channel:)
-        @config[:slack] = { channel: channel }
-      end
-
-      def email(to:)
-        @config[:email] = { to: to }
-      end
-
-      def to_h
-        @config
-      end
-    end
   end
 end

data/lib/language_operator/templates/agent_synthesis.tmpl

@@ -0,0 +1,243 @@
+You are generating Ruby DSL code for an autonomous agent in a Kubernetes operator.
+
+{{if .ErrorContext}}
+## IMPORTANT: Self-Healing Synthesis - Attempt {{.AttemptNumber}}
+
+The previous code synthesis encountered errors. Please analyze the errors below and generate CORRECTED code.
+
+### Previous Synthesis Failures
+
+{{if .ErrorContext.ValidationErrors}}
+**Validation Errors** (detected during code generation):
+{{range .ErrorContext.ValidationErrors}}
+- {{.}}
+{{end}}
+{{end}}
+
+{{if .ErrorContext.RuntimeErrors}}
+**Runtime Errors** (detected during execution):
+{{range .ErrorContext.RuntimeErrors}}
+- Time: {{.Timestamp}}
+- Type: {{.ErrorType}}
+- Message: {{.ErrorMessage}}
+{{if .StackTrace}}
+- Stack Trace:
+{{range .StackTrace}}
+  {{.}}
+{{end}}
+{{end}}
+- Exit Code: {{.ContainerExitCode}}
+{{end}}
+{{end}}
+
+{{if .ErrorContext.LastCrashLog}}
+**Last Container Logs** (before crash):
+```
+{{.ErrorContext.LastCrashLog}}
+```
+{{end}}
+
+### Your Task
+
+1. Carefully analyze each error above
+2. Identify the root cause of the failure
+3. Generate CORRECTED Ruby DSL code that addresses ALL errors
+4. Ensure the code:
+   - Fixes the specific errors mentioned
+   - Uses only available tools: {{.ToolsList}}
+   - Uses only available models: {{.ModelsList}}
+   - Follows the Language Operator DSL syntax exactly
+   - Does NOT use any dangerous Ruby methods (system, eval, etc.)
+
+This is attempt {{.AttemptNumber}} of {{.MaxAttempts}}. The user is counting on you to get it right!
+
+{{if .LastKnownGoodCode}}
+### Last Known Working Code (for reference)
+```ruby
+{{.LastKnownGoodCode}}
+```
+{{end}}
+
+{{else}}
+## Agent Synthesis Request
+{{end}}
+
+**User Instructions:**
+{{.Instructions}}
+
+**Available Tools:**
+{{.ToolsList}}
+
+**Available Models:**
+{{.ModelsList}}
+
+**Agent Name:** {{.AgentName}}
+
+**Detected Temporal Intent:** {{.TemporalIntent}}
+
+**Runtime Context:**
+- All agent messages and output are automatically logged to stdout
+- Agents have access to a workspace directory for file operations
+- LLM responses are captured and available in agent execution context
+
+## DSL v1 Reference Examples
+
+Study these examples to understand the task/main model with organic functions:
+
+### Example 1: Simple Scheduled Agent (Fully Neural)
+```ruby
+agent "daily-report" do
+  description "Generate daily sales report"
+  mode :scheduled
+  schedule "0 9 * * *"
+
+  task :fetch_sales,
+    instructions: "fetch yesterday's sales data from database",
+    inputs: {},
+    outputs: { sales: 'array', total: 'number' }
+
+  task :generate_report,
+    instructions: "create a markdown report summarizing the sales",
+    inputs: { sales: 'array', total: 'number' },
+    outputs: { report: 'string' }
+
+  main do |inputs|
+    sales_data = execute_task(:fetch_sales)
+    report = execute_task(:generate_report, inputs: sales_data)
+    report
+  end
+
+  output do |outputs|
+    puts outputs[:report]
+  end
+end
+```
+
+### Example 2: Hybrid Neural-Symbolic Agent
+```ruby
+agent "code-reviewer" do
+  description "Review pull requests"
+
+  # Symbolic task - deterministic tool call
+  task :fetch_pr_diff do |inputs|
+    {
+      diff: execute_tool('github', 'get_pr_diff', pr_number: inputs[:pr_number])
+    }
+  end
+
+  # Neural task - creative analysis
+  task :analyze_code,
+    instructions: "review code changes for bugs and improvements",
+    inputs: { diff: 'string' },
+    outputs: { issues: 'array', severity: 'string' }
+
+  # Symbolic task - deterministic logic
+  task :should_approve do |inputs|
+    critical = inputs[:issues].select { |i| i['severity'] == 'critical' }
+    { approve: critical.empty? }
+  end
+
+  main do |inputs|
+    pr_data = execute_task(:fetch_pr_diff, inputs: inputs)
+    analysis = execute_task(:analyze_code, inputs: pr_data)
+    decision = execute_task(:should_approve, inputs: analysis)
+    analysis.merge(decision)
+  end
+end
+```
+
+### Example 3: Multi-Step Agent with Tools
+```ruby
+agent "data-pipeline" do
+  description "ETL pipeline"
+
+  task :extract_data,
+    instructions: "extract data from the source database",
+    inputs: { source: 'string' },
+    outputs: { records: 'array', count: 'integer' }
+
+  task :transform_data,
+    instructions: "clean and normalize the records",
+    inputs: { records: 'array' },
+    outputs: { cleaned_records: 'array' }
+
+  task :load_data,
+    instructions: "load cleaned records into warehouse",
+    inputs: { cleaned_records: 'array' },
+    outputs: { success: 'boolean', loaded_count: 'integer' }
+
+  main do |inputs|
+    extracted = execute_task(:extract_data, inputs: inputs)
+    transformed = execute_task(:transform_data, inputs: extracted)
+    result = execute_task(:load_data, inputs: transformed)
+    result
+  end
+end
+```
+
+## Your Task: Generate DSL v1 Agent
+
+Using the examples above as reference, generate Ruby DSL code in this format:
+
+```ruby
+require 'language_operator'
+
+agent "{{.AgentName}}" do
+  description "Brief description extracted from instructions"
+{{.PersonaSection}}{{.ScheduleSection}}
+  # Break down instructions into tasks
+  # Each task needs:
+  # - instructions: what to do (for neural tasks)
+  # - inputs: hash with parameter types
+  # - outputs: hash with result types
+
+  task :task_name,
+    instructions: "clear description of what this task does",
+    inputs: { param_name: 'type' },
+    outputs: { result_name: 'type' }
+
+  # For symbolic tasks (when logic is simple/deterministic), use code blocks:
+  # task :task_name do |inputs|
+  #   { result: inputs[:param] * 2 }
+  # end
+
+  # REQUIRED: main block defines execution flow
+  main do |inputs|
+    result1 = execute_task(:task_name, inputs: { param_name: value })
+    # Chain tasks by passing outputs as inputs
+    result2 = execute_task(:another_task, inputs: result1)
+    result2  # Return final result
+  end
+
+{{.ConstraintsSection}}
+
+  # Output handling
+  output do |outputs|
+    # Save results, send notifications, etc.
+    puts "Agent completed: #{outputs.inspect}"
+  end
+end
+```
+
+**Type System:**
+- `'string'` - text values
+- `'integer'` - whole numbers
+- `'number'` - decimal numbers
+- `'boolean'` - true/false
+- `'array'` - lists
+- `'hash'` - key-value objects
+- `'any'` - any type
+
+**Rules:**
+1. Generate ONLY the Ruby code within triple-backticks, no explanations before or after
+{{.ScheduleRules}}
+3. Break down instructions into clear tasks with type-safe contracts
+4. REQUIRED: Always include a `main` block that calls tasks via `execute_task()`
+5. For simple deterministic tasks, use symbolic code blocks (do |inputs| ... end)
+6. For complex/creative tasks, use neural tasks with instructions
+7. Chain tasks by passing outputs as inputs
+8. Use available tools: {{.ToolsList}}
+9. Type schemas are REQUIRED for all tasks (inputs/outputs hashes)
+10. Use the agent name: "{{.AgentName}}"
+
+Generate the code now:

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

data/lib/language_operator/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: language-operator
 version: !ruby/object:Gem::Version
-  version: 0.1.36
+  version: 0.1.38
 platform: ruby
 authors:
 - James Ryan
@@ -135,6 +135,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: k8s-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -397,7 +411,6 @@ extra_rdoc_files: []
 files:
 - ".rubocop.yml"
 - CHANGELOG.md
-- CI_STATUS.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -506,8 +519,8 @@ files:
 - lib/language_operator/retryable.rb
 - lib/language_operator/synthesis_test_harness.rb
 - lib/language_operator/templates/README.md
-- lib/language_operator/templates/examples/agent_synthesis.tmpl
-- lib/language_operator/templates/examples/persona_distillation.tmpl
+- lib/language_operator/templates/agent_synthesis.tmpl
+- lib/language_operator/templates/persona_distillation.tmpl
 - lib/language_operator/templates/schema/.gitkeep
 - lib/language_operator/templates/schema/CHANGELOG.md
 - lib/language_operator/templates/schema/agent_dsl_openapi.yaml

data/CI_STATUS.md

@@ -1,56 +0,0 @@
-# CI Integration Test Status
-
-## Summary
-
-The CI integration tests are significantly improved from their previous completely broken state.
-
-### Fixed Issues
-
-1. **Numeric Constant Error** ✅
-   - **Problem**: SafeExecutor sandbox was blocking access to Ruby type constants (Numeric, Integer, Float, etc.)
-   - **Solution**: Inject type constants into the evaluated code scope in SafeExecutor#eval
-   - **Impact**: All symbolic tasks using type checking now work correctly
-
-2. **Neural Task Connection Errors** ✅  
-   - **Problem**: Agent tried to connect to real LLM when INTEGRATION_MOCK_LLM=true, failing with "Not connected"
-   - **Solution**: Create mock chat object in create_test_agent when mocking is enabled
-   - **Impact**: Neural tasks can now execute without real LLM connection
-
-3. **Deep Symbol Keys** ✅
-   - **Problem**: Nested hashes in neural task outputs had string keys, tests expected symbol keys
-   - **Solution**: Implement deep_symbolize_keys in TaskExecutor#parse_neural_response
-   - **Impact**: Nested hash structures now match test expectations
-
-4. **Multi-Provider LLM Support** ✅
-   - **Problem**: Tests only supported OpenAI
-   - **Solution**: Added support for SYNTHESIS_*, ANTHROPIC_*, and OPENAI_API_KEY env vars
-   - **Impact**: Tests can use local models, Claude, or OpenAI
-
-### Current Test Status
-
-**Passing Tests** (28/72, 39%):
-- ✅ Comprehensive DSL v1 Integration (all 4 scenarios)
-- ✅ Symbolic Task Execution (complete)
-- ✅ Error Handling (skipped DSL syntax issues)
-- ✅ Type Coercion (partial)
-
-**Failing Tests** (44/72, 61%):
-- ❌ Neural Task Execution - individual mocks don't match all output schemas
-- ❌ Hybrid Agent Execution - some neural tasks failing
-- ❌ Parallel Execution - some neural tasks failing
-
-**Pending Tests**: 20 (performance benchmarks disabled)
-
-### Recommendations
-
-For full CI coverage with mocked LLMs, consider:
-1. Use real LLM in CI (with API key secrets) instead of mocking
-2. Add schema-aware mock generation based on task output definitions  
-3. Add individual mocks for each failing neural task (tedious but thorough)
-
-### Bottom Line
-
-**Before**: 100% failure rate - all tests broken
-**After**: 39% pass rate with core functionality working
-
-The most critical tests (comprehensive integration) now pass. The CI is in a MUCH better state than before.

data/lib/language_operator/templates/examples/agent_synthesis.tmpl

@@ -1,133 +0,0 @@
-You are generating Ruby DSL code for an autonomous agent in a Kubernetes operator.
-
-{{if .ErrorContext}}
-## IMPORTANT: Self-Healing Synthesis - Attempt {{.AttemptNumber}}
-
-The previous code synthesis encountered errors. Please analyze the errors below and generate CORRECTED code.
-
-### Previous Synthesis Failures
-
-{{if .ErrorContext.ValidationErrors}}
-**Validation Errors** (detected during code generation):
-{{range .ErrorContext.ValidationErrors}}
-- {{.}}
-{{end}}
-{{end}}
-
-{{if .ErrorContext.RuntimeErrors}}
-**Runtime Errors** (detected during execution):
-{{range .ErrorContext.RuntimeErrors}}
-- Time: {{.Timestamp}}
-- Type: {{.ErrorType}}
-- Message: {{.ErrorMessage}}
-{{if .StackTrace}}
-- Stack Trace:
-{{range .StackTrace}}
-  {{.}}
-{{end}}
-{{end}}
-- Exit Code: {{.ContainerExitCode}}
-{{end}}
-{{end}}
-
-{{if .ErrorContext.LastCrashLog}}
-**Last Container Logs** (before crash):
-```
-{{.ErrorContext.LastCrashLog}}
-```
-{{end}}
-
-### Your Task
-
-1. Carefully analyze each error above
-2. Identify the root cause of the failure
-3. Generate CORRECTED Ruby DSL code that addresses ALL errors
-4. Ensure the code:
-   - Fixes the specific errors mentioned
-   - Uses only available tools: {{.ToolsList}}
-   - Uses only available models: {{.ModelsList}}
-   - Follows the Language Operator DSL syntax exactly
-   - Does NOT use any dangerous Ruby methods (system, eval, etc.)
-
-This is attempt {{.AttemptNumber}} of {{.MaxAttempts}}. The user is counting on you to get it right!
-
-{{if .LastKnownGoodCode}}
-### Last Known Working Code (for reference)
-```ruby
-{{.LastKnownGoodCode}}
-```
-{{end}}
-
-{{else}}
-## Agent Synthesis Request
-{{end}}
-
-**User Instructions:**
-{{.Instructions}}
-
-**Available Tools:**
-{{.ToolsList}}
-
-**Available Models:**
-{{.ModelsList}}
-
-**Agent Name:** {{.AgentName}}
-
-**Detected Temporal Intent:** {{.TemporalIntent}}
-
-**Runtime Context:**
-- All agent messages and output are automatically logged to stdout
-- Agents have access to a workspace directory for file operations
-- LLM responses are captured and available in agent execution context
-
-Generate Ruby DSL code using this exact format (wrapped in triple-backticks with ruby):
-
-```ruby
-require 'language_operator'
-
-agent "{{.AgentName}}" do
-  description "Brief description extracted from instructions"
-{{.PersonaSection}}{{.ScheduleSection}}
-  # Extract objectives from instructions
-  objectives [
-    "First objective",
-    "Second objective"
-  ]
-
-  # REQUIRED: Define workflow with at least one step
-  workflow do
-    # Use tools when available
-    step :step_name, tool: "tool_name", params: {key: "value"}
-
-    # Or use execute blocks for custom Ruby code (simple logging, calculations, etc.)
-    step :custom_step do
-      execute do
-        puts "Custom output from Ruby code"
-        { result: "done" }
-      end
-    end
-
-    # Chain steps with dependencies if needed
-    step :another_step, depends_on: :step_name
-  end
-
-{{.ConstraintsSection}}
-
-  # Output configuration (if workspace enabled)
-  output do
-    workspace "results/output.txt"
-  end
-end
-```
-
-**Rules:**
-1. Generate ONLY the Ruby code within triple-backticks, no explanations before or after
-{{.ScheduleRules}}
-5. Break down instructions into clear, actionable objectives
-6. REQUIRED: Always include a workflow block with at least one step (even for simple single-action agents)
-7. For simple tasks (logging, calculations), use a single step with an execute block containing Ruby code
-8. For complex tasks, use multiple steps with tools or execute blocks
-9. Use available tools in workflow steps when tools are provided
-10. Use the agent name: "{{.AgentName}}"
-
-Generate the code now: