language-operator 0.1.30 → 0.1.35

data/lib/language_operator/dsl/agent_context.rb

@@ -13,14 +13,14 @@ module LanguageOperator
     #
     #     schedule "0 12 * * *"
     #
-    #     objectives [
-    #       "Search for recent news",
-    #       "Summarize findings"
-    #     ]
+    #     task :search,
+    #       instructions: "search for recent news",
+    #       inputs: {},
+    #       outputs: { results: 'array' }
     #
-    #     workflow do
-    #       step :search, tool: "web_search"
-    #       step :summarize, depends_on: :search
+    #     main do |inputs|
+    #       results = execute_task(:search)
+    #       results
     #     end
     #   end
     class AgentContext

data/lib/language_operator/dsl/agent_definition.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'workflow_definition'
+require_relative 'main_definition'
+require_relative 'task_definition'
 require_relative 'webhook_definition'
 require_relative 'mcp_server_definition'
 require_relative 'chat_endpoint_definition'
@@ -11,7 +12,7 @@ module LanguageOperator
   module Dsl
     # Agent definition for autonomous agents
     #
-    # Defines an agent with objectives, workflow, schedule, and constraints.
+    # Defines an agent with objectives, tasks, main execution block, schedule, and constraints.
     # Used within the DSL to create agents that can be executed standalone
     # or deployed to Kubernetes.
     #
@@ -21,14 +22,14 @@ module LanguageOperator
     #
     #     schedule "0 12 * * *"
     #
-    #     objectives [
-    #       "Search for recent news",
-    #       "Summarize findings"
-    #     ]
+    #     task :search,
+    #       instructions: "search for latest news",
+    #       inputs: {},
+    #       outputs: { results: 'array' }
     #
-    #     workflow do
-    #       step :search, tool: "web_search", params: {query: "latest news"}
-    #       step :summarize, depends_on: :search
+    #     main do |inputs|
+    #       results = execute_task(:search)
+    #       results
     #     end
     #   end
     #
@@ -47,7 +48,7 @@ module LanguageOperator
     class AgentDefinition
       include LanguageOperator::Loggable
 
-      attr_reader :name, :description, :persona, :schedule, :objectives, :workflow,
+      attr_reader :name, :description, :persona, :schedule, :objectives, :main, :tasks,
                   :constraints, :output_config, :execution_mode, :webhooks, :mcp_server, :chat_endpoint
 
       def initialize(name)
@@ -56,7 +57,8 @@ module LanguageOperator
         @persona = nil
         @schedule = nil
         @objectives = []
-        @workflow = nil
+        @main = nil
+        @tasks = {}
         @constraints = {}
         @output_config = {}
         @execution_mode = :autonomous
@@ -118,16 +120,95 @@ module LanguageOperator
         @objectives << text
       end
 
-      # Define workflow with steps
+      # Define main execution block (DSL v1)
       #
-      # @yield Workflow definition block
-      # @return [WorkflowDefinition] Current workflow
-      def workflow(&block)
-        return @workflow if block.nil?
+      # The main block is the imperative entry point for agent execution.
+      # It receives agent inputs and returns agent outputs. Use execute_task()
+      # to call organic functions (tasks) defined with the task directive.
+      #
+      # @yield Main execution block
+      # @return [MainDefinition] Current main definition
+      # @example
+      #   main do |inputs|
+      #     result = execute_task(:fetch_data, inputs: inputs)
+      #     execute_task(:process_data, inputs: result)
+      #   end
+      def main(&block)
+        return @main if block.nil?
+
+        @main = MainDefinition.new
+        @main.execute(&block) if block
+        @main
+      end
+
+      # Define a task (organic function) - DSL v1
+      #
+      # Tasks are the core primitive of DSL v1, representing organic functions with
+      # stable input/output contracts. Tasks can be neural (instructions-based),
+      # symbolic (code-based), or hybrid (both).
+      #
+      # @param name [Symbol] Task name
+      # @param options [Hash] Task configuration
+      # @option options [Hash] :inputs Input schema (param => type)
+      # @option options [Hash] :outputs Output schema (field => type)
+      # @option options [String] :instructions Natural language instructions (neural)
+      # @yield [inputs] Symbolic implementation block (optional)
+      # @yieldparam inputs [Hash] Validated input parameters
+      # @yieldreturn [Hash] Output matching outputs schema
+      # @return [TaskDefinition] The task definition
+      #
+      # @example Neural task
+      #   task :analyze_data,
+      #     instructions: "Analyze the data for anomalies",
+      #     inputs: { data: 'array' },
+      #     outputs: { issues: 'array', summary: 'string' }
+      #
+      # @example Symbolic task
+      #   task :calculate_total,
+      #     inputs: { items: 'array' },
+      #     outputs: { total: 'number' }
+      #   do |inputs|
+      #     { total: inputs[:items].sum { |i| i['amount'] } }
+      #   end
+      #
+      # @example Hybrid task
+      #   task :fetch_user,
+      #     instructions: "Fetch user from database",
+      #     inputs: { user_id: 'integer' },
+      #     outputs: { user: 'hash' }
+      #   do |inputs|
+      #     execute_tool('database', 'get_user', id: inputs[:user_id])
+      #   end
+      def task(name, **options, &block)
+        # Create task definition
+        task_def = TaskDefinition.new(name)
+
+        # Configure from options (keyword arguments)
+        task_def.inputs(options[:inputs]) if options[:inputs]
+        task_def.outputs(options[:outputs]) if options[:outputs]
+        task_def.instructions(options[:instructions]) if options[:instructions]
+
+        # Symbolic implementation (if block provided)
+        task_def.execute(&block) if block
+
+        # Store in tasks collection
+        @tasks[name] = task_def
+
+        task_type = if task_def.neural? && task_def.symbolic?
+                      'hybrid'
+                    elsif task_def.neural?
+                      'neural'
+                    else
+                      'symbolic'
+                    end
+
+        logger.debug('Task defined',
+                     name: name,
+                     type: task_type,
+                     inputs: options[:inputs]&.keys || [],
+                     outputs: options[:outputs]&.keys || [])
 
-        @workflow = WorkflowDefinition.new
-        @workflow.instance_eval(&block) if block
-        @workflow
+        task_def
       end
 
       # Define constraints (max_iterations, timeout, etc.)
@@ -213,7 +294,7 @@ module LanguageOperator
                     name: @name,
                     mode: @execution_mode,
                     objectives_count: @objectives.size,
-                    has_workflow: !@workflow.nil?)
+                    has_main: !@main.nil?)
 
         case @execution_mode
         when :scheduled
@@ -317,7 +398,7 @@ module LanguageOperator
       def execute_objectives
         logger.info('Executing objectives',
                     total: @objectives.size,
-                    has_workflow: !@workflow.nil?)
+                    has_main: !@main.nil?)
 
         @objectives.each_with_index do |objective, index|
           logger.info('Executing objective',
@@ -325,13 +406,13 @@ module LanguageOperator
                       total: @objectives.size,
                       objective: objective[0..100])
 
-          # If workflow defined, execute it; otherwise just log
-          if @workflow
-            logger.timed('Objective workflow execution') do
-              @workflow.execute(objective)
+          # If main defined, execute it; otherwise just log
+          if @main
+            logger.timed('Objective main execution') do
+              @main.call({ objective: objective })
             end
           else
-            logger.warn('No workflow defined, skipping execution')
+            logger.warn('No main block defined, skipping execution')
           end
         end
 
@@ -353,6 +434,10 @@ module LanguageOperator
         @constraints[:timeout] = value
       end
 
+      def max_retries(value)
+        @constraints[:max_retries] = value
+      end
+
       def memory(value)
         @constraints[:memory] = value
       end

data/lib/language_operator/dsl/config.rb

@@ -4,8 +4,11 @@ module LanguageOperator
   module Dsl
     # Configuration helper for managing environment variables
     #
-    # Provides utilities for reading and managing environment variables with fallback support,
-    # type conversion, and validation. All methods are class methods.
+    # This class delegates to LanguageOperator::Config for all functionality.
+    # It exists for backwards compatibility with existing code that uses
+    # Dsl::Config.
+    #
+    # @deprecated Use LanguageOperator::Config directly instead
     #
     # @example Basic usage
     #   Config.get('SMTP_HOST', 'MAIL_HOST', default: 'localhost')
@@ -13,92 +16,45 @@ module LanguageOperator
     #   Config.get_bool('USE_TLS', default: true)
     class Config
       # Get environment variable with multiple fallback keys
-      #
-      # @param keys [Array<String>] Environment variable names to try
-      # @param default [Object, nil] Default value if none found
-      # @return [String, nil] The first non-nil value or default
+      # Delegates to LanguageOperator::Config.get
       def self.get(*keys, default: nil)
-        keys.each do |key|
-          value = ENV.fetch(key.to_s, nil)
-          return value if value
-        end
-        default
+        LanguageOperator::Config.get(*keys, default: default)
       end
 
       # Get required environment variable with fallback keys
-      #
-      # @param keys [Array<String>] Environment variable names to try
-      # @return [String] The first non-nil value
-      # @raise [ArgumentError] If none of the keys are set
+      # Delegates to LanguageOperator::Config.require
       def self.require(*keys)
-        value = get(*keys)
-        raise ArgumentError, "Missing required configuration: #{keys.join(' or ')}" unless value
-
-        value
+        LanguageOperator::Config.require(*keys)
       end
 
       # Get environment variable as integer
-      #
-      # @param keys [Array<String>] Environment variable names to try
-      # @param default [Integer, nil] Default value if none found
-      # @return [Integer, nil] The value converted to integer, or default
+      # Delegates to LanguageOperator::Config.get_int
       def self.get_int(*keys, default: nil)
-        value = get(*keys)
-        return default if value.nil?
-
-        value.to_i
+        LanguageOperator::Config.get_int(*keys, default: default)
       end
 
       # Get environment variable as boolean
-      #
-      # Treats 'true', '1', 'yes', 'on' as true (case insensitive).
-      #
-      # @param keys [Array<String>] Environment variable names to try
-      # @param default [Boolean] Default value if none found
-      # @return [Boolean] The value as boolean
+      # Delegates to LanguageOperator::Config.get_bool
       def self.get_bool(*keys, default: false)
-        value = get(*keys)
-        return default if value.nil?
-
-        value.to_s.downcase.match?(/^(true|1|yes|on)$/)
+        LanguageOperator::Config.get_bool(*keys, default: default)
       end
 
-      # Get environment variable as array (split by separator)
-      #
-      # @param keys [Array<String>] Environment variable names to try
-      # @param default [Array] Default value if none found
-      # @param separator [String] Character to split on (default: ',')
-      # @return [Array<String>] The value split into array
+      # Get environment variable as array
+      # Delegates to LanguageOperator::Config.get_array
       def self.get_array(*keys, default: [], separator: ',')
-        value = get(*keys)
-        return default if value.nil? || value.empty?
-
-        value.split(separator).map(&:strip).reject(&:empty?)
+        LanguageOperator::Config.get_array(*keys, default: default, separator: separator)
       end
 
-      # Check if all required keys are present
-      #
-      # @param keys [Array<String>] Environment variable names to check
-      # @return [Array<String>] Array of missing keys (empty if all present)
-      def self.check_required(*keys)
-        keys.reject { |key| ENV.fetch(key.to_s, nil) }
-      end
-
-      # Check if environment variable is set (even if empty string)
-      #
-      # @param keys [Array<String>] Environment variable names to check
-      # @return [Boolean] True if any key is set
+      # Check if environment variable is set
+      # Delegates to LanguageOperator::Config.set?
       def self.set?(*keys)
-        keys.any? { |key| ENV.key?(key.to_s) }
+        LanguageOperator::Config.set?(*keys)
       end
 
       # Get all environment variables matching a prefix
-      #
-      # @param prefix [String] Prefix to match
-      # @return [Hash<String, String>] Hash with prefix removed from keys
+      # Delegates to LanguageOperator::Config.with_prefix
       def self.with_prefix(prefix)
-        ENV.select { |key, _| key.start_with?(prefix) }
-           .transform_keys { |key| key.sub(prefix, '') }
+        LanguageOperator::Config.with_prefix(prefix)
       end
 
       # Build a configuration hash from environment variables
@@ -109,11 +65,19 @@ module LanguageOperator
         config = {}
         mappings.each do |config_key, env_keys|
           env_keys = [env_keys] unless env_keys.is_a?(Array)
-          value = get(*env_keys)
+          value = LanguageOperator::Config.get(*env_keys)
           config[config_key] = value if value
         end
         config
       end
+
+      # Check if all required keys are present
+      #
+      # @param keys [Array<String>] Environment variable names to check
+      # @return [Array<String>] Array of missing keys (empty if all present)
+      def self.check_required(*keys)
+        keys.reject { |key| ENV.fetch(key.to_s, nil) }
+      end
     end
   end
 end

data/lib/language_operator/dsl/main_definition.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../loggable'
+
+module LanguageOperator
+  module Dsl
+    # Main execution block for agents (DSL v1)
+    #
+    # Defines the imperative entry point for agent execution. The main block receives
+    # agent inputs and returns agent outputs. Within the block, agents can call tasks
+    # using execute_task(), use standard Ruby control flow (if/else, loops), and handle
+    # errors with standard Ruby exceptions.
+    #
+    # This replaces the declarative workflow/step model with an imperative programming
+    # model centered on organic functions (tasks).
+    #
+    # @example Simple main block
+    #   main do |inputs|
+    #     result = execute_task(:fetch_data, inputs: inputs)
+    #     execute_task(:process_data, inputs: result)
+    #   end
+    #
+    # @example Main block with control flow
+    #   main do |inputs|
+    #     data = execute_task(:fetch_data, inputs: inputs)
+    #
+    #     if data[:count] > 100
+    #       execute_task(:send_alert, inputs: { count: data[:count] })
+    #     end
+    #
+    #     execute_task(:save_results, inputs: data)
+    #   end
+    #
+    # @example Main block with error handling
+    #   main do |inputs|
+    #     begin
+    #       result = execute_task(:risky_operation, inputs: inputs)
+    #       { success: true, result: result }
+    #     rescue => e
+    #       logger.error("Operation failed: #{e.message}")
+    #       { success: false, error: e.message }
+    #     end
+    #   end
+    class MainDefinition
+      include LanguageOperator::Loggable
+
+      attr_reader :execute_block
+
+      # Initialize a new main definition
+      def initialize
+        @execute_block = nil
+      end
+
+      # Define the main execution block
+      #
+      # @yield [inputs] Block that receives agent inputs and returns agent outputs
+      # @yieldparam inputs [Hash] Agent input parameters
+      # @yieldreturn [Object] Agent output (typically a Hash)
+      # @return [void]
+      # @example
+      #   execute do |inputs|
+      #     result = execute_task(:my_task, inputs: inputs)
+      #     result
+      #   end
+      def execute(&block)
+        raise ArgumentError, 'Main block is required' unless block
+
+        @execute_block = block
+        logger.debug('Main block defined', arity: block.arity)
+      end
+
+      # Execute the main block with given inputs
+      #
+      # @param inputs [Hash] Agent input parameters
+      # @param context [Object] Execution context that provides execute_task method
+      # @return [Object] Result from main block
+      # @raise [RuntimeError] If main block is not defined
+      # @raise [ArgumentError] If inputs is not a Hash
+      def call(inputs, context)
+        raise 'Main block not defined. Use execute { |inputs| ... } to define it.' unless @execute_block
+        raise ArgumentError, "inputs must be a Hash, got #{inputs.class}" unless inputs.is_a?(Hash)
+
+        logger.info('Executing main block', inputs_keys: inputs.keys)
+
+        result = logger.timed('Main execution') do
+          # Execute block in context to provide access to execute_task
+          context.instance_exec(inputs, &@execute_block)
+        end
+
+        logger.info('Main block completed')
+        result
+      rescue StandardError => e
+        logger.error('Main block execution failed',
+                     error: e.class.name,
+                     message: e.message,
+                     backtrace: e.backtrace&.first(5))
+        raise
+      end
+
+      # Check if main block is defined
+      #
+      # @return [Boolean] True if execute block is set
+      def defined?
+        !@execute_block.nil?
+      end
+
+      private
+
+      def logger_component
+        'Main'
+      end
+    end
+  end
+end