language-operator 0.1.38 → 0.1.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4476732244850657fb5161189ad68010e2ffdef4f4949361786893d119f0de89
-  data.tar.gz: 5755720ffc0df24c88c5ec5ea223a4f8899c604f938422e420e878833d172de5
+  metadata.gz: 6e670a07610f07576228d91fbe02a1ac45e5ce43633bc9b4fc9974db52a04b08
+  data.tar.gz: ed8ef8e1e9a9a132582a734676f7aff1745565690fbbe40d7046fc058a3f3b6e
 SHA512:
-  metadata.gz: a4408235ba4cc775fc175f7760e0632e78457630b263690efeb3ddc772c58facfcd7b7e0780a38d33bda5c4f9d3d12b46eed0f83d43631c94f1ddfe7180be61d
-  data.tar.gz: 3ccbd9c8c91ef1d19ae467cafe3740cc84586853692cf46569d77b692b1cddf682fb21300bbb75244e71335b84a10fde768f6baff1016d18acf8b4c31a869862
+  metadata.gz: f6b727e3736603600df84f13c9c0ea3b3bb98335fc1eabcd20669ccc8908b3b13c631125fe6362bb5f3f13218f4f558c4b37b224d04d2d36bdc32059c8234b18
+  data.tar.gz: 8f0ff851ae3cb6b573b315c35e1158db30ec066d74861968be6751a8bb47a99259a28320c553f56face105e17893d81f6e9946ccac8d7f85dfce0b83084862b6

data/Gemfile.lock

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

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

@@ -50,6 +50,27 @@ module LanguageOperator
       load_and_run(agent)
     end
 
+    # Load and run agent from a specific file path
+    #
+    # @param code_path [String] Path to agent DSL code file
+    # @param agent_name [String, nil] Name of the agent definition to run
+    # @param config_path [String, nil] Path to configuration file
+    # @return [void]
+    def self.load_and_run_from_file(code_path, agent_name = nil, config_path: nil)
+      # Disable stdout buffering for real-time logging in containers
+      $stdout.sync = true
+      $stderr.sync = true
+
+      config_path ||= ENV.fetch('CONFIG_PATH', 'config.yaml')
+      config = LanguageOperator::Client::Config.load_with_fallback(config_path)
+
+      # Create agent instance
+      agent = LanguageOperator::Agent::Base.new(config)
+
+      # Load and run the specified agent code
+      load_synthesized_agent(agent, code_path, agent_name)
+    end
+
     # Load synthesized agent code and run with definition if available
     #
     # @param agent [LanguageOperator::Agent::Base] The agent instance
@@ -191,9 +212,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/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.38
+  :version: 0.1.40
   :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.38",
+  "version": "0.1.40",
   "type": "object",
   "properties": {
     "name": {

data/lib/language_operator/version.rb

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

metadata

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