language-operator 0.1.37 → 0.1.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b57f326a81a7683900ef0700d54b97c296019f74e044dc886cc8aa02703e5a3
-  data.tar.gz: 7ba35359cc513dd5d53df60269f7052449453032c6ce749631e5dd6d80983a66
+  metadata.gz: a3674b7904fe01e280096b7e7c37ce8be922379d75a194e31ffd5239b082e7b8
+  data.tar.gz: 61cd4ab21b5495b537cb4babbe5e0a14c4890a93b9b1f2a1d4d4069c53c3ddc1
 SHA512:
-  metadata.gz: 62327e75b4357c55c1de51fbb56eebe4a16faede2b3ead5591a0dd2b8dc8760116130f9e9820ca47499aaa5ad3e285048862db7fef788d96416c4cc9fe123560
-  data.tar.gz: 0f63c9ca8e9523f6825a053cbd02a21ccd4103067b36ad190fb78316df051d0b6972a36917fd2a4ef9f26e449deaaaac487a83ae63e9f562fd9c317a8df2f490
+  metadata.gz: 33714e1bd58eb58d54101a038954a1fbd425ffa34904fdfc8cb3dcb9ba83b0090d445343071190b7bb48e599d8691d99b4918f8a9eab2ecf135634f92c7825ac
+  data.tar.gz: 235149dfa2f126e31b8450426d70ebb25f39badb30b343e274c7b50ab0d7b3674f224ffae251589967c4ea47022b171af3f0212cd466bc6c994171534e0b48ef

data/Gemfile.lock

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

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/agent/task_executor.rb

@@ -445,15 +445,16 @@ module LanguageOperator
 
       # Execute the actual task implementation (neural or symbolic)
       #
+      # For hybrid tasks (both neural and symbolic), prefer symbolic execution
+      # as it's more efficient and deterministic.
+      #
       # @param task [TaskDefinition] The task definition
       # @param inputs [Hash] Input parameters
       # @return [Hash] Task outputs
       def execute_task_implementation(task, inputs)
-        if task.neural?
-          # Neural execution: LLM with tool access
-          execute_neural(task, inputs)
-        else
+        if task.symbolic?
           # Symbolic execution: Direct Ruby code within traced span
+          # This takes precedence over neural for hybrid tasks
           tracer.in_span('task_executor.symbolic', attributes: symbolic_task_attributes(task)) do |span|
             validated_inputs = task.validate_inputs(inputs)
             span.set_attribute('task.input.keys', validated_inputs.keys.map(&:to_s).join(','))
@@ -465,6 +466,12 @@ module LanguageOperator
             record_output_metadata(outputs, span) if outputs.is_a?(Hash)
             outputs
           end
+        elsif task.neural?
+          # Neural execution: LLM with tool access
+          # Only used for pure neural tasks (no symbolic implementation)
+          execute_neural(task, inputs)
+        else
+          raise ArgumentError, "Task '#{task.name}' has neither neural nor symbolic implementation"
         end
       end
 

data/lib/language_operator/agent.rb

@@ -191,9 +191,43 @@ module LanguageOperator
       logger.info('Main block execution completed',
                   result: result)
 
+      # Call output handler if defined
+      if agent_def.output
+        logger.debug('Executing output handler', outputs: result)
+        execute_output_handler(agent_def, result, task_executor)
+      end
+
       result
     end
 
+    # Execute the output handler (neural or symbolic)
+    #
+    # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
+    # @param outputs [Hash] The outputs from main execution
+    # @param task_executor [LanguageOperator::Agent::TaskExecutor] Task executor for context
+    # @return [void]
+    def self.execute_output_handler(agent_def, outputs, task_executor)
+      output_config = agent_def.output
+
+      # 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, task_executor is context
+        output_config.execute_symbolic(outputs, task_executor)
+      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
+
     # Build executor configuration from agent definition constraints
     #
     # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition

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/kubernetes/client.rb

@@ -97,7 +97,14 @@ module LanguageOperator
       def create_resource(resource)
         resource_client = resource_client_for_resource(resource)
         # Convert hash to K8s::Resource if needed
-        k8s_resource = resource.is_a?(K8s::Resource) ? resource : K8s::Resource.new(resource)
+        k8s_resource = if resource.is_a?(K8s::Resource)
+                         resource
+                       else
+                         # Remove resourceVersion if present - it should not be set on new resources
+                         resource_hash = resource.dup
+                         resource_hash['metadata']&.delete('resourceVersion')
+                         K8s::Resource.new(resource_hash)
+                       end
         resource_client.create_resource(k8s_resource)
       end
 

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

data/lib/language_operator/version.rb

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

metadata

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