language-operator 0.1.37 → 0.1.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b57f326a81a7683900ef0700d54b97c296019f74e044dc886cc8aa02703e5a3
-  data.tar.gz: 7ba35359cc513dd5d53df60269f7052449453032c6ce749631e5dd6d80983a66
+  metadata.gz: 4476732244850657fb5161189ad68010e2ffdef4f4949361786893d119f0de89
+  data.tar.gz: 5755720ffc0df24c88c5ec5ea223a4f8899c604f938422e420e878833d172de5
 SHA512:
-  metadata.gz: 62327e75b4357c55c1de51fbb56eebe4a16faede2b3ead5591a0dd2b8dc8760116130f9e9820ca47499aaa5ad3e285048862db7fef788d96416c4cc9fe123560
-  data.tar.gz: 0f63c9ca8e9523f6825a053cbd02a21ccd4103067b36ad190fb78316df051d0b6972a36917fd2a4ef9f26e449deaaaac487a83ae63e9f562fd9c317a8df2f490
+  metadata.gz: a4408235ba4cc775fc175f7760e0632e78457630b263690efeb3ddc772c58facfcd7b7e0780a38d33bda5c4f9d3d12b46eed0f83d43631c94f1ddfe7180be61d
+  data.tar.gz: 3ccbd9c8c91ef1d19ae467cafe3740cc84586853692cf46569d77b692b1cddf682fb21300bbb75244e71335b84a10fde768f6baff1016d18acf8b4c31a869862

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.37)
+    language-operator (0.1.38)
       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/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/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.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.37",
+  "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.37'
+  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.37
+  version: 0.1.38
 platform: ruby
 authors:
 - James Ryan