language-operator 0.1.71 → 0.1.80

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11da2ddaf7396a49d94451edc45cd07a05b8ac2d9239b587f46cf7b5a938714f
-  data.tar.gz: 998d0061d7a4a7fee8a61de4b034766bceb4421363cf177b4e6e38ada37c04b0
+  metadata.gz: 2e6aa13623ea7f320f5be1ffbf252aa2320fdcb951c658905c43476f63f30a2a
+  data.tar.gz: a2136ce8803e111628610981f33b3ae5c9332662b97aaf36f483b0a144403e2a
 SHA512:
-  metadata.gz: 44f424c8f7ff4a5d147f86027a7e68e4bfacbda5ed3a0747793c35e5967d58e339b001dc421eb3826c6d1cd359343fc74ea9de96cc0e1d5eeefd45d101ca3d1e
-  data.tar.gz: b74bcaf2d2762cccb6c282041b3cd40d6c1ffd6635dfc1920855f68ffbf9bbe8c46e5e8bb052e77d4807d0ba2c28eaf92b516649be4891cd64ca1a04ceaf476f
+  metadata.gz: f68216fc87b0d38c29ac06d2d133dba4f5cbef23a4a8a848a91205c3545e4757123fccbc7a51f7e2e7940d6e7168c76af3cd6ab380f52ae7cc520256d4d1d352
+  data.tar.gz: 0c4c40b6e2c813e9b0dd4b2dcc2cd9a8083ae56cbbd9b26512298f640f176e8d28ff872a4479a100ff7be58b80c3b949f1dd40925691573dc3a1ed11a834f7c7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    language-operator (0.1.71)
+    language-operator (0.1.80)
       faraday (~> 2.0)
       json-schema (~> 5.0)
       k8s-ruby (~> 0.17)

data/components/agent/Gemfile

@@ -2,7 +2,7 @@
 
 source 'https://rubygems.org'
 
-gem 'language-operator', '~> 0.1.70'
+gem 'language-operator', '~> 0.1.71'
 
 # Agent-specific dependencies for autonomous execution
 gem 'concurrent-ruby', '~> 1.3'

data/components/tool/Gemfile

@@ -2,7 +2,7 @@
 
 source 'https://rubygems.org'
 
-gem 'language-operator', '~> 0.1.46'
+gem 'language-operator', '~> 0.1.71'
 
 # Tool server dependencies
 gem 'json', '~> 2.7'

data/lib/language_operator/agent/base.rb

@@ -107,24 +107,29 @@ module LanguageOperator
         @executor.run_loop
       end
 
-      # Run in scheduled mode (execute once - Kubernetes CronJob handles scheduling)
+      # Run in scheduled mode (standby - waits for HTTP triggers)
       #
       # @return [void]
       def run_scheduled
-        logger.info('Agent running in scheduled mode without definition - executing goal once')
+        logger.info('Agent running in scheduled mode (standby) - waiting for HTTP triggers')
 
-        goal = ENV.fetch('AGENT_INSTRUCTIONS', 'Complete the assigned task')
-        execute_goal(goal)
-
-        logger.info('Scheduled execution completed - exiting')
+        require_relative 'web_server'
+        @web_server = WebServer.new(self)
+        @web_server.register_execute_endpoint(self, nil)
+        @web_server.register_workspace_endpoints(self)
+        @web_server.start
       end
 
-      # Run in reactive mode (HTTP server)
+      # Run in reactive mode (standby - HTTP server with execute endpoint)
       #
       # @return [void]
       def run_reactive
+        logger.info('Agent running in reactive mode (standby) - web server only')
+
         require_relative 'web_server'
         @web_server = WebServer.new(self)
+        @web_server.register_execute_endpoint(self, nil) # Enable /api/v1/execute endpoint
+        @web_server.register_workspace_endpoints(self)
         @web_server.start
       end
 

data/lib/language_operator/agent/execution_state.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Agent
+    # Execution State Manager
+    #
+    # Manages the execution state of agents to prevent concurrent executions.
+    # Thread-safe implementation ensures only one execution runs at a time.
+    #
+    # @example Check if execution is running
+    #   state = ExecutionState.new
+    #   state.running? # => false
+    #
+    # @example Start an execution
+    #   state.start_execution('exec-123')
+    #   state.running? # => true
+    class ExecutionState
+      attr_reader :current_execution_id, :started_at, :status
+
+      # Initialize a new execution state
+      def initialize
+        @mutex = Mutex.new
+        @current_execution_id = nil
+        @started_at = nil
+        @status = :idle # :idle, :running, :completed, :failed
+      end
+
+      # Start a new execution
+      #
+      # @param execution_id [String] Unique identifier for the execution
+      # @raise [ExecutionInProgressError] if an execution is already running
+      # @return [void]
+      def start_execution(execution_id)
+        @mutex.synchronize do
+          if @status == :running
+            raise ExecutionInProgressError,
+                  "Execution #{@current_execution_id} already running"
+          end
+
+          @current_execution_id = execution_id
+          @started_at = Time.now
+          @status = :running
+        end
+      end
+
+      # Mark execution as completed
+      #
+      # @param result [Object] Optional execution result
+      # @return [Object] The result passed in
+      def complete_execution(result = nil)
+        @mutex.synchronize do
+          @status = :completed
+          result
+        end
+      end
+
+      # Mark execution as failed
+      #
+      # @param error [StandardError] The error that caused the failure
+      # @return [void]
+      def fail_execution(error)
+        @mutex.synchronize do
+          @status = :failed
+          @last_error = error
+        end
+      end
+
+      # Check if an execution is currently running
+      #
+      # @return [Boolean] true if execution is in progress
+      def running?
+        @mutex.synchronize { @status == :running }
+      end
+
+      # Get current execution information
+      #
+      # @return [Hash] Current execution state details
+      def current_info
+        @mutex.synchronize do
+          {
+            status: @status,
+            execution_id: @current_execution_id,
+            started_at: @started_at
+          }
+        end
+      end
+    end
+
+    # Error raised when attempting to start an execution while one is already running
+    class ExecutionInProgressError < StandardError; end
+  end
+end

data/lib/language_operator/agent/web_server.rb

@@ -3,6 +3,8 @@
 require 'rack'
 require 'rackup'
 require 'mcp'
+require 'fileutils'
+require 'securerandom'
 require_relative 'executor'
 require_relative 'prompt_builder'
 
@@ -30,6 +32,7 @@ module LanguageOperator
         @routes = {}
         @mcp_server = nil
         @mcp_transport = nil
+        @execution_state = nil # Initialized when register_execute_endpoint called
 
         # Initialize executor pool to prevent MCP connection leaks
         @executor_pool_size = ENV.fetch('EXECUTOR_POOL_SIZE', '4').to_i
@@ -118,7 +121,7 @@ module LanguageOperator
       # @return [void]
       def register_chat_endpoint(agent)
         @chat_agent = agent
-        
+
         # Create simple chat configuration (identity awareness always enabled)
         @chat_config = {
           model_name: ENV.fetch('AGENT_NAME', agent.config&.dig('agent', 'name') || 'agent'),
@@ -153,6 +156,65 @@ module LanguageOperator
         puts "Registered identity-aware chat endpoint as model: #{@chat_config[:model_name]}"
       end
 
+      # Register execution trigger endpoint
+      #
+      # Enables scheduled/reactive agents to execute tasks via HTTP POST.
+      # Prevents concurrent executions via ExecutionState.
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      # @param agent_def [LanguageOperator::Dsl::AgentDefinition, nil] Optional agent definition
+      # @return [void]
+      def register_execute_endpoint(agent, agent_def = nil)
+        require_relative 'execution_state'
+
+        @execute_agent = agent
+        @execute_agent_def = agent_def
+        @execution_state = LanguageOperator::Agent::ExecutionState.new
+
+        register_route('/api/v1/execute', method: :post) do |context|
+          handle_execute_request(context)
+        end
+
+        puts 'Registered /api/v1/execute endpoint for triggered execution'
+      end
+
+      # Register workspace file management endpoints
+      #
+      # @param agent [LanguageOperator::Agent::Base] The agent instance
+      def register_workspace_endpoints(agent)
+        return unless agent.workspace_available?
+
+        @workspace_agent = agent
+        @workspace_path = agent.workspace_path
+
+        # List directory contents
+        register_route('/api/v1/workspace/files', method: :get) do |context|
+          handle_workspace_list(context)
+        end
+
+        # View file contents
+        register_route('/api/v1/workspace/files/view', method: :get) do |context|
+          handle_workspace_view(context)
+        end
+
+        # Upload file
+        register_route('/api/v1/workspace/files', method: :post) do |context|
+          handle_workspace_upload(context)
+        end
+
+        # Delete file
+        register_route('/api/v1/workspace/files', method: :delete) do |context|
+          handle_workspace_delete(context)
+        end
+
+        # Download file/directory
+        register_route('/api/v1/workspace/files/download', method: :get) do |context|
+          handle_workspace_download(context)
+        end
+
+        puts 'Registered /api/v1/workspace/* endpoints for file management'
+      end
+
       # Handle incoming HTTP request
       #
       # @param env [Hash] Rack environment
@@ -207,10 +269,10 @@ module LanguageOperator
       # @param agent [LanguageOperator::Agent::Base] The agent instance
       # @return [String] Default system prompt
       def build_default_system_prompt(agent)
-        description = agent.config&.dig('agent', 'instructions') || 
-                     agent.config&.dig('agent', 'description') || 
-                     "AI assistant"
-        
+        description = agent.config&.dig('agent', 'instructions') ||
+                      agent.config&.dig('agent', 'description') ||
+                      'AI assistant'
+
         if description.downcase.start_with?('you are')
           description
         else
@@ -218,6 +280,145 @@ module LanguageOperator
         end
       end
 
+      # Handle POST /api/v1/execute request
+      #
+      # @param context [Hash] Request context with :body, :headers, :request
+      # @return [Hash] Response data
+      def handle_execute_request(context)
+        puts "Received execute request: #{context[:body]}"
+
+        # Check for concurrent execution
+        if @execution_state.running?
+          info = @execution_state.current_info
+          puts "Execution already running: #{info}"
+          return {
+            status: 409,
+            body: {
+              error: 'ExecutionInProgress',
+              message: 'Agent is currently executing a task',
+              current_execution: info
+            }.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          }
+        end
+
+        # Parse request
+        request_data = JSON.parse(context[:body] || '{}')
+        puts "Parsed request data: #{request_data.inspect}"
+
+        execution_id = "exec-#{SecureRandom.hex(8)}"
+        puts "Generated execution ID: #{execution_id}"
+
+        wait_for_completion = request_data.fetch('wait', true)
+        puts "Execution details - ID: #{execution_id}, wait: #{wait_for_completion}"
+
+        # Start execution
+        puts 'About to start execution state...'
+        @execution_state.start_execution(execution_id)
+        puts "Started execution state for #{execution_id}"
+
+        if wait_for_completion
+          execute_sync(execution_id, request_data['context'])
+        else
+          execute_async(execution_id, request_data['context'])
+        end
+      rescue JSON::ParserError
+        execute_error_response(400, 'InvalidJSON', 'Request body must be valid JSON')
+      rescue LanguageOperator::Agent::ExecutionInProgressError => e
+        execute_error_response(409, 'ExecutionInProgress', e.message)
+      rescue StandardError => e
+        puts "Exception in handle_execute_request: #{e.class}: #{e.message}"
+        puts "Exception backtrace: #{e.backtrace.first(5).join('\n')}"
+        @execution_state&.fail_execution(e)
+        execute_error_response(500, 'ExecutionError', e.message)
+      end
+
+      # Execute task synchronously
+      #
+      # @param execution_id [String] Execution identifier
+      # @param context_data [Hash] Additional context data
+      # @return [Hash] Response data
+      def execute_sync(execution_id, _context_data)
+        start_time = Time.now
+        puts "Starting execution #{execution_id}"
+
+        # Execute agent main block (convention: all DSL agents have main blocks)
+        puts 'About to execute main block...'
+        $stdout.flush
+
+        # Test logging capture during execution
+        original_stdout = $stdout
+        original_stderr = $stderr
+        puts "Original stdout: #{original_stdout.class}"
+        puts "Original stderr: #{original_stderr.class}"
+        $stdout.flush
+
+        result = LanguageOperator::Agent.execute_main_block(@execute_agent, @execute_agent_def)
+
+        puts "Main block execution returned: #{result.inspect}"
+        puts "Stdout after execution: #{$stdout.class}"
+        puts "Stderr after execution: #{$stderr.class}"
+        $stdout.flush
+
+        puts "Execution #{execution_id} completed with result: #{result.inspect}"
+        @execution_state.complete_execution(result)
+
+        {
+          status: 200,
+          body: {
+            status: 'completed',
+            result: result,
+            execution_id: execution_id,
+            started_at: start_time.iso8601,
+            completed_at: Time.now.iso8601,
+            duration_seconds: (Time.now - start_time).round(2)
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      # Execute task asynchronously
+      #
+      # @param execution_id [String] Execution identifier
+      # @param context_data [Hash] Additional context data
+      # @return [Hash] Response data
+      def execute_async(execution_id, _context_data)
+        Thread.new do
+          result = LanguageOperator::Agent.execute_main_block(@execute_agent, @execute_agent_def)
+          @execution_state.complete_execution(result)
+        rescue StandardError => e
+          @execution_state.fail_execution(e)
+          logger.error('Async execution failed', error: e.message, execution_id: execution_id)
+        end
+
+        {
+          status: 202,
+          body: {
+            status: 'accepted',
+            execution_id: execution_id,
+            message: 'Execution started asynchronously'
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      # Generate error response for execute endpoint
+      #
+      # @param status [Integer] HTTP status code
+      # @param error_type [String] Error type identifier
+      # @param message [String] Error message
+      # @return [Hash] Error response data
+      def execute_error_response(status, error_type, message)
+        {
+          status: status,
+          body: {
+            error: error_type,
+            message: message
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
       # Setup executor pool for connection reuse
       #
       # Creates a thread-safe queue pre-populated with executor instances
@@ -431,7 +632,7 @@ module LanguageOperator
       # @param context [Hash] Request context
       # @return [Array, Hash] Rack response or hash for streaming
       def handle_chat_completion(context)
-        return error_response(StandardError.new('Chat endpoint not configured')) unless @chat_endpoint
+        return error_response(StandardError.new('Chat endpoint not configured')) unless @chat_config
 
         # Parse request body
         request_data = JSON.parse(context[:body])
@@ -534,7 +735,7 @@ module LanguageOperator
             prompt_parts << "User: #{content}"
           when 'assistant'
             prompt_parts << "Assistant: #{content}"
-          # Skip system messages - we handle them via PromptBuilder
+            # Skip system messages - we handle them via PromptBuilder
           end
         end
 
@@ -548,8 +749,8 @@ module LanguageOperator
         # Create prompt builder with identity awareness always enabled
         builder = PromptBuilder.new(
           @chat_agent,
-          nil,  # No chat config needed
-          template: :standard,  # Good default
+          nil, # No chat config needed
+          template: :standard, # Good default
           enable_identity_awareness: true
         )
 
@@ -566,7 +767,7 @@ module LanguageOperator
       def build_conversation_context
         builder = PromptBuilder.new(
           @chat_agent,
-          nil,  # No chat config needed
+          nil, # No chat config needed
           enable_identity_awareness: true
         )
 
@@ -764,6 +965,331 @@ module LanguageOperator
       ensure
         stream.close
       end
+
+      # Workspace file management handlers
+
+      # Handle GET /api/v1/workspace/files - list directory contents
+      def handle_workspace_list(context)
+        request = context[:request]
+        path = request.params['path'] || '/'
+
+        # Sanitize path to prevent directory traversal
+        safe_path = sanitize_workspace_path(path)
+        full_path = File.join(@workspace_path, safe_path)
+
+        return workspace_error_response(404, 'NotFound', "Path not found: #{path}") unless File.exist?(full_path)
+
+        if File.directory?(full_path)
+          list_directory_contents(full_path, path)
+        else
+          # If it's a file, return file info
+          get_file_info(full_path, path)
+        end
+      rescue StandardError => e
+        workspace_error_response(500, 'InternalError', e.message)
+      end
+
+      # Handle GET /api/v1/workspace/files/view - view file contents
+      def handle_workspace_view(context)
+        request = context[:request]
+        path = request.params['path']
+
+        return workspace_error_response(400, 'BadRequest', 'path parameter required') unless path
+
+        # Sanitize path to prevent directory traversal
+        safe_path = sanitize_workspace_path(path)
+        full_path = File.join(@workspace_path, safe_path)
+
+        return workspace_error_response(404, 'NotFound', "File not found: #{path}") unless File.exist?(full_path)
+
+        return workspace_error_response(400, 'BadRequest', "Path is not a file: #{path}") unless File.file?(full_path)
+
+        # Check file size (limit to 10MB for API responses)
+        file_size = File.size(full_path)
+        return workspace_error_response(413, 'FileTooLarge', 'File too large for viewing (max 10MB)') if file_size > 10 * 1024 * 1024
+
+        # Read file contents
+        contents = File.read(full_path)
+
+        {
+          status: 200,
+          body: {
+            path: path,
+            size: file_size,
+            modified: File.mtime(full_path).iso8601,
+            content: contents,
+            content_type: detect_content_type(full_path)
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      rescue StandardError => e
+        workspace_error_response(500, 'InternalError', e.message)
+      end
+
+      # Handle POST /api/v1/workspace/files - upload file
+      def handle_workspace_upload(context)
+        request = context[:request]
+
+        # Check for multipart form data
+        content_type = request.env['CONTENT_TYPE']
+        unless content_type&.start_with?('multipart/form-data')
+          return workspace_error_response(400, 'BadRequest', 'Content-Type must be multipart/form-data')
+        end
+
+        # Parse multipart data
+        begin
+          # Get file from params (Rack automatically parses multipart data)
+          file_param = request.params['file']
+          path_param = request.params['path']
+
+          return workspace_error_response(400, 'BadRequest', 'file parameter required') unless file_param
+
+          return workspace_error_response(400, 'BadRequest', 'path parameter required') unless path_param
+
+          # Handle file upload object
+          return workspace_error_response(400, 'BadRequest', 'Invalid file upload format') unless file_param.is_a?(Hash) && file_param[:tempfile]
+
+          # Rack file upload format
+          tempfile = file_param[:tempfile]
+          original_filename = file_param[:filename]
+          content_type = file_param[:type]
+
+          # Sanitize target path
+          safe_path = sanitize_workspace_path(path_param)
+          full_path = File.join(@workspace_path, safe_path)
+
+          # Ensure target directory exists
+          target_dir = File.dirname(full_path)
+          FileUtils.mkdir_p(target_dir) unless File.directory?(target_dir)
+
+          # Check file size (limit to 100MB)
+          file_size = tempfile.size
+          return workspace_error_response(413, 'FileTooLarge', 'File too large for upload (max 100MB)') if file_size > 100 * 1024 * 1024
+
+          # Copy uploaded file to workspace
+          tempfile.rewind
+          File.open(full_path, 'wb') do |dest_file|
+            IO.copy_stream(tempfile, dest_file)
+          end
+
+          # Set reasonable permissions
+          File.chmod(0o644, full_path)
+
+          {
+            status: 201,
+            body: {
+              path: path_param,
+              size: file_size,
+              original_filename: original_filename,
+              content_type: content_type,
+              message: 'File uploaded successfully'
+            }.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          }
+        rescue StandardError => e
+          workspace_error_response(500, 'UploadError', "Upload failed: #{e.message}")
+        ensure
+          # Clean up temporary file
+          tempfile&.close if tempfile.respond_to?(:close)
+        end
+      end
+
+      # Handle DELETE /api/v1/workspace/files - delete file
+      def handle_workspace_delete(context)
+        request = context[:request]
+        path = request.params['path']
+
+        return workspace_error_response(400, 'BadRequest', 'path parameter required') unless path
+
+        # Sanitize path to prevent directory traversal
+        safe_path = sanitize_workspace_path(path)
+        full_path = File.join(@workspace_path, safe_path)
+
+        return workspace_error_response(404, 'NotFound', "Path not found: #{path}") unless File.exist?(full_path)
+
+        begin
+          deleted_info = {
+            path: path,
+            type: File.directory?(full_path) ? 'directory' : 'file',
+            size: File.directory?(full_path) ? nil : File.size(full_path)
+          }
+
+          if File.directory?(full_path)
+            # Delete directory and all contents
+            FileUtils.rm_rf(full_path)
+            deleted_info[:message] = 'Directory deleted successfully'
+          else
+            # Delete single file
+            File.delete(full_path)
+            deleted_info[:message] = 'File deleted successfully'
+          end
+
+          {
+            status: 200,
+            body: deleted_info.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          }
+        rescue StandardError => e
+          workspace_error_response(500, 'DeleteError', "Delete failed: #{e.message}")
+        end
+      end
+
+      # Handle GET /api/v1/workspace/files/download - download file/archive
+      def handle_workspace_download(context)
+        request = context[:request]
+        path = request.params['path']
+
+        return workspace_error_response(400, 'BadRequest', 'path parameter required') unless path
+
+        # Sanitize path to prevent directory traversal
+        safe_path = sanitize_workspace_path(path)
+        full_path = File.join(@workspace_path, safe_path)
+
+        return workspace_error_response(404, 'NotFound', "Path not found: #{path}") unless File.exist?(full_path)
+
+        begin
+          if File.directory?(full_path)
+            # Create temporary tar.gz archive for directory
+            archive_name = "#{File.basename(safe_path.empty? ? 'workspace' : safe_path)}.tar.gz"
+            temp_archive = "/tmp/#{SecureRandom.hex(8)}_#{archive_name}"
+
+            # Create tar archive
+            system('tar', '-czf', temp_archive, '-C', File.dirname(full_path), File.basename(full_path))
+
+            return workspace_error_response(500, 'ArchiveError', 'Failed to create archive') unless File.exist?(temp_archive)
+
+            # Read archive contents
+            archive_data = File.binread(temp_archive)
+
+            # Clean up temporary file
+            File.delete(temp_archive)
+
+            {
+              status: 200,
+              body: archive_data,
+              headers: {
+                'Content-Type' => 'application/gzip',
+                'Content-Disposition' => "attachment; filename=\"#{archive_name}\"",
+                'Content-Length' => archive_data.length.to_s
+              }
+            }
+          else
+            # Direct file download
+            file_data = File.binread(full_path)
+            filename = File.basename(safe_path)
+            content_type = detect_content_type(full_path)
+
+            # For binary files, use application/octet-stream
+            content_disposition = if content_type == 'application/octet-stream'
+                                    "attachment; filename=\"#{filename}\""
+                                  else
+                                    # For text files, allow inline viewing
+                                    "inline; filename=\"#{filename}\""
+                                  end
+
+            {
+              status: 200,
+              body: file_data,
+              headers: {
+                'Content-Type' => content_type,
+                'Content-Disposition' => content_disposition,
+                'Content-Length' => file_data.length.to_s
+              }
+            }
+          end
+        rescue StandardError => e
+          workspace_error_response(500, 'DownloadError', "Download failed: #{e.message}")
+        end
+      end
+
+      private
+
+      # Sanitize workspace path to prevent directory traversal attacks
+      def sanitize_workspace_path(path)
+        # Remove leading slash and resolve relative paths
+        clean_path = path.sub(%r{^/+}, '')
+
+        # Resolve and normalize the path
+        normalized = File.expand_path(clean_path, '/')
+
+        # Ensure it doesn't escape the root
+        return '' if normalized == '/' || !normalized.start_with?('/')
+
+        # Remove leading slash for joining with workspace_path
+        normalized[1..]
+      end
+
+      # List directory contents
+      def list_directory_contents(full_path, requested_path)
+        entries = Dir.entries(full_path).reject { |entry| entry.start_with?('.') }
+
+        files = entries.map do |entry|
+          entry_path = File.join(full_path, entry)
+          relative_path = File.join(requested_path == '/' ? '' : requested_path, entry)
+
+          {
+            name: entry,
+            path: "/#{relative_path}".gsub(%r{/+}, '/'),
+            type: File.directory?(entry_path) ? 'directory' : 'file',
+            size: File.directory?(entry_path) ? nil : File.size(entry_path),
+            modified: File.mtime(entry_path).iso8601
+          }
+        end
+
+        files.sort_by! { |f| [f[:type] == 'directory' ? 0 : 1, f[:name]] }
+
+        {
+          status: 200,
+          body: {
+            path: requested_path,
+            files: files,
+            total: files.length
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      # Get file info for a single file
+      def get_file_info(full_path, requested_path)
+        {
+          status: 200,
+          body: {
+            path: requested_path,
+            type: 'file',
+            size: File.size(full_path),
+            modified: File.mtime(full_path).iso8601
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
+
+      # Detect content type based on file extension
+      def detect_content_type(file_path)
+        case File.extname(file_path).downcase
+        when '.txt', '.log' then 'text/plain'
+        when '.json' then 'application/json'
+        when '.yml', '.yaml' then 'application/x-yaml'
+        when '.md' then 'text/markdown'
+        when '.html' then 'text/html'
+        when '.css' then 'text/css'
+        when '.js' then 'application/javascript'
+        when '.py' then 'text/x-python'
+        when '.rb' then 'text/x-ruby'
+        else 'application/octet-stream'
+        end
+      end
+
+      # Generate workspace API error response
+      def workspace_error_response(status, error_type, message)
+        {
+          status: status,
+          body: {
+            error: error_type,
+            message: message
+          }.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      end
     end
   end
 end

data/lib/language_operator/agent.rb

@@ -4,6 +4,7 @@ require_relative 'agent/base'
 require_relative 'agent/executor'
 require_relative 'agent/task_executor'
 require_relative 'agent/web_server'
+require_relative 'agent/execution_state'
 require_relative 'agent/instrumentation'
 require_relative 'dsl'
 require_relative 'logger'
@@ -162,15 +163,14 @@ module LanguageOperator
         # Hybrid mode: All agents now run main work AND web server (chat endpoints always enabled)
         logger.info('Starting hybrid agent (autonomous + web server)',
                     agent_name: agent_def.name,
-                    chat_endpoint_enabled: true,  # Always true now
+                    chat_endpoint_enabled: true, # Always true now
                     has_webhooks: agent_def.webhooks.any?,
-                    has_mcp_tools: !!(agent_def.mcp_server&.tools?))
+                    has_mcp_tools: !!agent_def.mcp_server&.tools?)
 
         # Start web server in background thread
         web_server = LanguageOperator::Agent::WebServer.new(agent)
         agent_def.webhooks.each { |webhook_def| webhook_def.register(web_server) }
-        web_server.register_mcp_tools(agent_def.mcp_server) if agent_def.mcp_server&.tools?
-        web_server.register_chat_endpoint(agent_def.chat_endpoint, agent)  # Always register chat endpoint
+        register_standard_endpoints(web_server, agent, agent_def)
 
         web_thread = Thread.new do
           web_server.start
@@ -199,33 +199,30 @@ module LanguageOperator
           raise 'Agent definition must have either main block (DSL v1) or workflow (DSL v0)'
         end
       when 'scheduled', 'event-driven'
-        # Scheduled mode: Execute once and exit (Kubernetes CronJob handles scheduling)
-        logger.info('Agent running in scheduled mode - executing once',
+        # Standby mode - web server only, wait for /api/v1/execute triggers
+        logger.info('Starting agent in standby mode (scheduled) - waiting for HTTP triggers',
                     agent_name: agent_def.name,
-                    dsl_version: uses_dsl_v1 ? 'v1' : 'v0')
-
-        if uses_dsl_v1
-          # DSL v1: Execute main block once
-          execute_main_block(agent, agent_def)
-        elsif uses_dsl_v0
-          # DSL v0: Execute workflow once
-          executor = LanguageOperator::Agent::Executor.new(agent)
-          executor.execute_workflow(agent_def)
-        else
-          raise 'Agent definition must have either main block (DSL v1) or workflow (DSL v0)'
-        end
+                    chat_endpoint_enabled: true,
+                    has_webhooks: agent_def.webhooks.any?,
+                    has_mcp_tools: !!agent_def.mcp_server&.tools?)
 
-        logger.info('Scheduled execution completed - exiting',
-                    agent_name: agent_def.name)
+        web_server = LanguageOperator::Agent::WebServer.new(agent)
+        agent_def.webhooks.each { |webhook_def| webhook_def.register(web_server) }
+        register_standard_endpoints(web_server, agent, agent_def)
+        web_server.register_execute_endpoint(agent, agent_def)
 
-        # Flush telemetry for short-lived processes
-        agent.send(:flush_telemetry)
+        web_server.start # Blocks here, waiting for requests
       when 'reactive', 'http', 'webhook'
-        # Start web server with webhooks, MCP tools, and chat endpoint
+        # Standby mode - web server with webhooks, MCP tools, chat, and execute endpoint
+        logger.info('Starting agent in standby mode (reactive)',
+                    agent_name: agent_def.name,
+                    has_webhooks: agent_def.webhooks.any?)
+
         web_server = LanguageOperator::Agent::WebServer.new(agent)
         agent_def.webhooks.each { |webhook_def| webhook_def.register(web_server) }
-        web_server.register_mcp_tools(agent_def.mcp_server) if agent_def.mcp_server&.tools?
-        web_server.register_chat_endpoint(agent_def.chat_endpoint, agent) if agent_def.chat_endpoint
+        register_standard_endpoints(web_server, agent, agent_def)
+        web_server.register_execute_endpoint(agent, agent_def)
+
         web_server.start
       else
         raise "Unknown agent mode: #{agent.mode}"
@@ -233,6 +230,18 @@ module LanguageOperator
     end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+    # Register standard endpoints for web server
+    #
+    # @param web_server [LanguageOperator::Agent::WebServer] The web server instance
+    # @param agent [LanguageOperator::Agent::Base] The agent instance
+    # @param agent_def [LanguageOperator::Dsl::AgentDefinition] The agent definition
+    # @return [void]
+    def self.register_standard_endpoints(web_server, agent, agent_def)
+      web_server.register_mcp_tools(agent_def.mcp_server) if agent_def.mcp_server&.tools?
+      web_server.register_chat_endpoint(agent)
+      web_server.register_workspace_endpoints(agent)
+    end
+
     # Execute main block (DSL v1) in autonomous mode
     #
     # @param agent [LanguageOperator::Agent::Base] The agent instance

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

data/lib/language_operator/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: language-operator
 version: !ruby/object:Gem::Version
-  version: 0.1.71
+  version: 0.1.80
 platform: ruby
 authors:
 - James Ryan
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mcp
@@ -533,6 +533,7 @@ files:
 - lib/language_operator/agent.rb
 - lib/language_operator/agent/base.rb
 - lib/language_operator/agent/event_config.rb
+- lib/language_operator/agent/execution_state.rb
 - lib/language_operator/agent/executor.rb
 - lib/language_operator/agent/instrumentation.rb
 - lib/language_operator/agent/metadata_collector.rb
@@ -698,7 +699,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.6.6
 specification_version: 4
 summary: Ruby SDK for Language Operator
 test_files: []