lex-acp 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbc2244fba03aff3fa5a32a841b9a576c511d6ba61558d74f52e4544b2155fc6
-  data.tar.gz: dae5536d6035f67546136f12ffe1fc52d602bdffc8dd5eeba120fec2313c4cd7
+  metadata.gz: 57e04c7371c8aca9db15606240a5c64db9bf528eab273e5fb1a7f5e07567ebae
+  data.tar.gz: e644ef521a23b59e93e2fa0dd40427a331a6531dc19692bf3544940f2308abb4
 SHA512:
-  metadata.gz: c491c34ce0965a055221ffb71af375720c9d6502fa860fd6bd33a78847e4174c608074923e473021338c50a6ffa5d56063c42b9fc66ad394adc7ccce3a057afb
-  data.tar.gz: 8cf8d948c812075b068479e25737a0d43999831f2dea87a018d6d62fe8c1049d96bb27076f88173ed91d4bd4ae1939669d768402ee9e8ce8e5c215c14014d909
+  metadata.gz: 9e0219a6a833657b12458a3db9835a10f34f014f46737f3a44a3e2d8ef642c6a09b4b68edecc1f009ad3b633f643852ded5f76709873b10f3cd74e6b36304a73
+  data.tar.gz: 20661c06e26be70e73e40e51e36a9aed6cc7d6aff960247e91f21fbfdcc5450ff16905245640584972df11fff7b8bdd555f2bf8a2dea2a72655862c92056aaf7

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec', '~> 3.13'
+gem 'rubocop', '~> 1.75', require: false

data/lex-acp.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'legion/extensions/acp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-acp'
+  spec.version       = Legion::Extensions::Acp::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+  spec.summary       = 'ACP agent protocol adapter for LegionIO'
+  spec.description   = 'Bidirectional Agent Communication Protocol adapter — exposes Legion agents via ACP and consumes external ACP agents'
+  spec.homepage      = 'https://github.com/LegionIO/lex-acp'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']          = spec.homepage
+  spec.metadata['source_code_uri']       = 'https://github.com/LegionIO/lex-acp'
+  spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/lex-acp'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-acp'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/lex-acp/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files         = Dir.glob('{lib,spec}/**/*') + %w[lex-acp.gemspec Gemfile]
+  spec.require_paths = ['lib']
+end

data/lib/legion/extensions/acp/actors/discovery.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Acp
+      module Actors
+        class Discovery < (defined?(Legion::Extensions::Actors::Every) ? Legion::Extensions::Actors::Every : Object)
+          class << self
+            attr_accessor :time
+          end
+          self.time = 300
+
+          def runner_class
+            'Legion::Extensions::Acp::Runners::Acp'
+          end
+
+          def runner_function
+            :discover_agents
+          end
+
+          def use_runner?
+            true
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+
+          def args
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/acp/helpers/agent_card.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module Legion
+  module Extensions
+    module Acp
+      module Helpers
+        module AgentCard
+          CARD_PATH = '/.well-known/agent.json'
+          FETCH_TIMEOUT = 5
+
+          module_function
+
+          def build(name:, url:, capabilities: [], description: nil)
+            {
+              name:               name,
+              description:        description || 'LegionIO digital worker',
+              url:                url,
+              version:            '2.0',
+              protocol:           'acp/1.0',
+              capabilities:       capabilities,
+              authentication:     { schemes: ['bearer'] },
+              defaultInputModes:  ['text/plain', 'application/json'],
+              defaultOutputModes: ['text/plain', 'application/json']
+            }
+          end
+
+          def parse(json)
+            data = if json.is_a?(String)
+                     ::JSON.parse(json, symbolize_names: true)
+                   else
+                     json.transform_keys(&:to_sym)
+                   end
+            return nil unless data[:name] && data[:url]
+
+            data
+          rescue StandardError
+            nil
+          end
+
+          def fetch(base_url, timeout: FETCH_TIMEOUT)
+            uri = URI.join("#{base_url.chomp('/')}/", CARD_PATH.delete_prefix('/'))
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = uri.scheme == 'https'
+            http.open_timeout = timeout
+            http.read_timeout = timeout
+
+            response = http.get(uri.request_uri)
+            return nil unless response.is_a?(Net::HTTPSuccess)
+
+            parse(response.body)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/acp/helpers/capabilities.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Acp
+      module Helpers
+        module Capabilities
+          PROTOCOL_VERSION = 1
+
+          module_function
+
+          def agent_info
+            version = defined?(Legion::VERSION) ? Legion::VERSION : Acp::VERSION
+            {
+              name:            'LegionIO',
+              version:         version,
+              protocolVersion: PROTOCOL_VERSION,
+              capabilities:    agent_capabilities,
+              authMethods:     []
+            }
+          end
+
+          def agent_capabilities
+            caps = { loadSession: true }
+
+            if llm_available?
+              caps[:promptCapabilities] = {
+                supportedMediaTypes:  ['text/plain'],
+                supportedStopReasons: %w[end_turn cancelled error]
+              }
+              caps[:sessionCapabilities] = {
+                supportedModes: %w[code chat]
+              }
+            end
+
+            caps
+          end
+
+          def custom_commands
+            [
+              { name: 'run_task',        description: 'Invoke a Legion runner function (e.g. extension.runner.function key:val)' },
+              { name: 'list_extensions', description: 'List loaded Legion extensions' },
+              { name: 'query_workers',   description: 'Show digital worker status' },
+              { name: 'list_schedules',  description: 'List scheduled jobs' }
+            ]
+          end
+
+          def llm_available?
+            defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/acp/helpers/protocol.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Legion
+  module Extensions
+    module Acp
+      module Helpers
+        module Protocol
+          JSONRPC_VERSION = '2.0'
+
+          PARSE_ERROR      = -32_700
+          INVALID_REQUEST  = -32_600
+          METHOD_NOT_FOUND = -32_601
+          INVALID_PARAMS   = -32_602
+          INTERNAL_ERROR   = -32_603
+
+          module_function
+
+          def parse(json_string)
+            data = ::JSON.parse(json_string, symbolize_names: true)
+            return error_response(id: nil, code: INVALID_REQUEST, message: 'Invalid Request') unless data.is_a?(Hash)
+            return error_response(id: data[:id], code: INVALID_REQUEST, message: 'Invalid Request') unless data[:jsonrpc] == JSONRPC_VERSION
+
+            return error_response(id: data[:id], code: INVALID_REQUEST, message: 'Invalid Request') if data.key?(:id) && !data.key?(:method)
+
+            data
+          rescue ::JSON::ParserError
+            error_response(id: nil, code: PARSE_ERROR, message: 'Parse error')
+          end
+
+          def request(id:, method:, params: nil)
+            msg = { jsonrpc: JSONRPC_VERSION, id: id, method: method }
+            msg[:params] = params if params
+            msg
+          end
+
+          def response(id:, result:)
+            { jsonrpc: JSONRPC_VERSION, id: id, result: result }
+          end
+
+          def error_response(id:, code:, message:, data: nil)
+            err = { code: code, message: message }
+            err[:data] = data if data
+            { jsonrpc: JSONRPC_VERSION, id: id, error: err }
+          end
+
+          def notification(method:, params: nil)
+            msg = { jsonrpc: JSONRPC_VERSION, method: method }
+            msg[:params] = params if params
+            msg
+          end
+
+          def serialize(hash)
+            ::JSON.generate(hash)
+          end
+
+          def read(io)
+            loop do
+              line = io.gets
+              return nil if line.nil?
+
+              line = line.strip
+              next if line.empty?
+
+              return parse(line)
+            end
+          end
+
+          def write(io, message)
+            io.puts(serialize(message))
+            io.flush
+          end
+
+          def dispatch(message, handlers)
+            method_name = message[:method]
+            handler = handlers[method_name]
+            return error_response(id: message[:id], code: METHOD_NOT_FOUND, message: "Method not found: #{method_name}") unless handler
+
+            handler.call(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/acp/helpers/task_translator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Acp
+      module Helpers
+        module TaskTranslator
+          module_function
+
+          def acp_to_legion(acp_task)
+            input = acp_task[:input] || acp_task['input'] || {}
+            {
+              payload:      input.transform_keys(&:to_sym),
+              source:       'acp',
+              runner_class: acp_task[:runner_class],
+              function:     acp_task[:function]
+            }.compact
+          end
+
+          def legion_to_acp(legion_result)
+            success = legion_result[:success]
+            {
+              task_id:      legion_result[:task_id],
+              status:       success ? 'completed' : 'failed',
+              output:       { data: legion_result[:result] || legion_result[:reason] },
+              created_at:   legion_result[:created_at]&.to_s,
+              completed_at: Time.now.utc.to_s
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/acp/runners/acp.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require_relative '../helpers/agent_card'
+require_relative '../helpers/task_translator'
+
+module Legion
+  module Extensions
+    module Acp
+      module Runners
+        module Acp
+          def invoke_agent(agent_url:, task:, timeout: 30, **)
+            card = Helpers::AgentCard.fetch(agent_url)
+            return { success: false, reason: :unreachable } unless card
+
+            register_in_mesh(card, agent_url)
+            response = submit_acp_task(card[:url], task, timeout)
+            { success: true, task_id: response[:task_id], result: response[:output] }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+
+          def register_external(agent_url:, **)
+            card = Helpers::AgentCard.fetch(agent_url)
+            return { success: false, reason: :unreachable } unless card
+
+            register_in_mesh(card, agent_url)
+            { success: true, agent_id: card[:name] }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+
+          def list_agents(**)
+            agents = mesh_registry.all_agents
+            { success: true, agents: agents, count: agents.size }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+
+          def discover_agents(**)
+            urls = acp_settings[:agents] || []
+            registered = 0
+            urls.each do |url|
+              result = register_external(agent_url: url)
+              registered += 1 if result[:success]
+            end
+            { success: true, scanned: urls.size, registered: registered }
+          rescue StandardError => e
+            { success: false, reason: :error, message: e.message }
+          end
+
+          private
+
+          def submit_acp_task(agent_url, task, timeout)
+            uri = URI.join("#{agent_url.chomp('/')}/", 'tasks')
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = uri.scheme == 'https'
+            http.open_timeout = timeout
+            http.read_timeout = timeout
+
+            request = Net::HTTP::Post.new(uri.request_uri, 'Content-Type' => 'application/json')
+            request.body = ::JSON.dump(task)
+            response = http.request(request)
+
+            ::JSON.parse(response.body, symbolize_names: true)
+          end
+
+          def register_in_mesh(card, agent_url)
+            return unless defined?(Legion::Extensions::Mesh)
+
+            mesh = mesh_registry
+            mesh.register_agent(
+              card[:name],
+              capabilities: (card[:capabilities] || []).map(&:to_sym),
+              endpoint:     agent_url,
+              source:       :acp
+            )
+          rescue StandardError
+            nil
+          end
+
+          def mesh_registry
+            @mesh_registry ||= (Legion::Extensions::Mesh::Helpers::Registry.new if defined?(Legion::Extensions::Mesh::Helpers::Registry))
+          end
+
+          def acp_settings
+            Legion::Settings[:acp] || {}
+          rescue StandardError
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/acp/runners/agent.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Acp
+      module Runners
+        class Agent
+          attr_reader :client_info, :sessions
+
+          def initialize(transport:)
+            @transport   = transport
+            @client_info = {}
+            @sessions    = {}
+            @handlers    = build_handler_map
+          end
+
+          def dispatch(message)
+            method_name = message[:method]
+            handler = @handlers[method_name]
+            unless handler
+              return Helpers::Protocol.error_response(
+                id:      message[:id],
+                code:    Helpers::Protocol::METHOD_NOT_FOUND,
+                message: "Method not found: #{method_name}"
+              )
+            end
+
+            handler.call(message)
+          end
+
+          def handle_initialize(msg)
+            @client_info         = msg.dig(:params, :clientInfo) || {}
+            @client_capabilities = msg.dig(:params, :capabilities) || {}
+
+            info = Helpers::Capabilities.agent_info
+
+            @transport.send_notification('session/update', {
+                                           commands: Helpers::Capabilities.custom_commands
+                                         })
+
+            info
+          end
+
+          def handle_session_new(_msg)
+            session_id = SecureRandom.uuid
+            @sessions[session_id] = {
+              id:         session_id,
+              created_at: Time.now.utc.iso8601,
+              mode:       'code',
+              config:     {},
+              cancelled:  false
+            }
+            { sessionId: session_id }
+          end
+
+          def handle_session_list(_msg)
+            session_list = @sessions.map do |id, session|
+              { sessionId: id, createdAt: session[:created_at], mode: session[:mode] }
+            end
+            { sessions: session_list }
+          end
+
+          def handle_session_cancel(msg)
+            session_id = msg.dig(:params, :sessionId)
+            session = @sessions[session_id]
+            return { error: "Session not found: #{session_id}" } unless session
+
+            session[:cancelled] = true
+            { success: true }
+          end
+
+          def handle_session_set_mode(msg)
+            session_id = msg.dig(:params, :sessionId)
+            session = @sessions[session_id]
+            return { error: "Session not found: #{session_id}" } unless session
+
+            mode = msg.dig(:params, :mode)
+            session[:mode] = mode
+            { success: true, mode: mode }
+          end
+
+          def handle_session_set_config_option(msg)
+            session_id = msg.dig(:params, :sessionId)
+            session = @sessions[session_id]
+            return { error: "Session not found: #{session_id}" } unless session
+
+            key   = msg.dig(:params, :key)
+            value = msg.dig(:params, :value)
+            session[:config][key.to_s] = value
+            { success: true }
+          end
+
+          def handle_session_prompt(msg)
+            session_id = msg.dig(:params, :sessionId)
+            session = @sessions[session_id]
+            return { error: "Session not found: #{session_id}" } unless session
+
+            user_text = msg.dig(:params, :prompt, :userMessage, :content) || ''
+
+            return handle_command(session, user_text) if user_text.start_with?('/')
+
+            return { error: 'LLM not available — prompt handling requires legion-llm' } unless Helpers::Capabilities.llm_available?
+
+            session[:cancelled] = false
+            chat = Legion::LLM.chat(model: session[:config]['model'], provider: session[:config]['provider']&.to_sym)
+            chat.with_instructions("You are LegionIO, an async job engine coding assistant. Mode: #{session[:mode]}.")
+
+            full_content = +''
+            response = chat.ask(user_text) do |chunk|
+              next if session[:cancelled]
+
+              text = chunk.respond_to?(:content) ? chunk.content : chunk.to_s
+              next if text.nil? || text.empty?
+
+              @transport.send_notification('session/update', { contentBlock: { type: 'text', text: text } })
+              full_content << text
+            end
+
+            final_content = if response.respond_to?(:content) && !response.content.nil?
+                              response.content
+                            else
+                              full_content
+                            end
+
+            stop_reason = session[:cancelled] ? 'cancelled' : 'end_turn'
+            { stopReason: stop_reason, content: final_content }
+          rescue StandardError => e
+            { error: "Prompt failed: #{e.message}", stopReason: 'error' }
+          end
+
+          private
+
+          def handle_command(_session, text)
+            parts   = text.sub(%r{^/}, '').split(' ', 2)
+            command = parts[0]
+            args    = parts[1]
+
+            result = case command
+                     when 'run_task'        then execute_run_task(args)
+                     when 'list_extensions' then execute_list_extensions
+                     when 'query_workers'   then execute_query_workers
+                     when 'list_schedules'  then execute_list_schedules
+                     else
+                       { content: "Unknown command: #{command}" }
+                     end
+
+            content = result.is_a?(Hash) ? ::JSON.generate(result) : result.to_s
+            @transport.send_notification('session/update', { contentBlock: { type: 'text', text: content } })
+            { stopReason: 'end_turn', content: content }
+          end
+
+          def execute_run_task(args)
+            return { error: 'Ingress not available' } unless defined?(Legion::Ingress)
+            return { error: 'Missing task arguments' } if args.nil? || args.empty?
+
+            parts       = args.split
+            runner_path = parts.shift
+            path_parts  = runner_path.split('.')
+            return { error: 'Invalid runner path — expected extension.runner.function' } unless path_parts.size >= 3
+
+            function     = path_parts.pop
+            runner_class = path_parts.map { |p| p.split('_').map(&:capitalize).join }.join('::')
+
+            payload = {}
+            parts.each do |pair|
+              key, value = pair.split(':', 2)
+              payload[key.to_sym] = value if key && value
+            end
+
+            Legion::Ingress.run(runner_class: runner_class, function: function, payload: payload, source: 'acp')
+          end
+
+          def execute_list_extensions
+            if defined?(Legion::Extensions) && Legion::Extensions.respond_to?(:loaded_extensions)
+              Legion::Extensions.loaded_extensions.map { |e| e.respond_to?(:name) ? e.name : e.to_s }
+            else
+              []
+            end
+          end
+
+          def execute_query_workers
+            if defined?(Legion::DigitalWorker::Registry)
+              Legion::DigitalWorker::Registry.all.map { |w| { id: w.id, name: w.name, status: w.status } }
+            else
+              []
+            end
+          end
+
+          def execute_list_schedules
+            if defined?(Legion::Ingress)
+              Legion::Ingress.run(runner_class: 'Runners::Scheduler', function: 'list', payload: {}, source: 'acp')
+            else
+              []
+            end
+          end
+
+          def build_handler_map
+            {
+              'initialize'                => method(:handle_initialize),
+              'session/new'               => method(:handle_session_new),
+              'session/list'              => method(:handle_session_list),
+              'session/cancel'            => method(:handle_session_cancel),
+              'session/set_mode'          => method(:handle_session_set_mode),
+              'session/set_config_option' => method(:handle_session_set_config_option),
+              'session/prompt'            => method(:handle_session_prompt)
+            }
+          end
+        end
+      end
+    end
+  end
+end