lex-uais 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b6c9562fc2b37ffa26eec00a63d7c0bd0bccb34feb807ba5f7f9e5a1d36d253f
+  data.tar.gz: 4b7a16c4dc99c84dd2766b770ce6f569ab65f2c46a442ae8b18dc3407ef08d51
+SHA512:
+  metadata.gz: 465dc286dcfcfa2471447df60517e57c727cc7e53a966b16ac69ed5c1766448cf1f5e871d72e9d9dace0c7818b721d4d4a8a1b87a0fa223e8d3347c3d632ed64
+  data.tar.gz: 3ad6cb3bf597404a8d5931e34b024661883236b1567c68605b0e708363dbd1ddbd0848c1125acb18e82a345c89a103b4718aa86c3b307289a12c449fc3eab565

data/.github/CODEOWNERS

@@ -0,0 +1,7 @@
+# Auto-generated from team-config.yml
+# Team: extensions
+#
+# To apply: scripts/apply-codeowners.sh lex-uais
+
+* @LegionIO/maintainers
+* @LegionIO/extensions

data/.github/workflows/ci.yml

@@ -0,0 +1,34 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+  schedule:
+    - cron: '0 9 * * 1'
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  lint:
+    uses: LegionIO/.github/.github/workflows/lint-patterns.yml@main
+
+  security:
+    uses: LegionIO/.github/.github/workflows/security-scan.yml@main
+
+  version-changelog:
+    uses: LegionIO/.github/.github/workflows/version-changelog.yml@main
+
+  dependency-review:
+    uses: LegionIO/.github/.github/workflows/dependency-review.yml@main
+
+  stale:
+    if: github.event_name == 'schedule'
+    uses: LegionIO/.github/.github/workflows/stale.yml@main
+
+  release:
+    needs: [ci, lint]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,50 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/MethodLength:
+  Max: 50
+
+Metrics/ClassLength:
+  Max: 1500
+
+Metrics/ModuleLength:
+  Max: 1500
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 60
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Style/Documentation:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Naming/FileName:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## [0.1.0] - 2026-03-27
+
+### Added
+- Initial release
+- UAIS agent registration client (register, deregister, check, AIRB status)
+- Mock adapter for development/testing (default when no base_url configured)
+- Soft-warn enforcement (registration failures log warnings, never block)
+- Net::HTTP-based connection helper
+- Standalone Client class for use outside Legion framework

data/CLAUDE.md

@@ -0,0 +1,75 @@
+# lex-uais: UAIS Registration Extension for LegionIO
+
+**Repository Level 3 Documentation**
+- **Parent (Level 2)**: `/Users/miverso2/rubymine/legion/extensions/CLAUDE.md`
+- **Parent (Level 1)**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Legion Extension that provides a client for United AI Studio (UAIS) agent registration. Registers, deregisters, and queries Digital Worker status with the UAIS platform. Defaults to mock mode when no `base_url` is configured, and uses soft-warn enforcement so registration failures never block operations.
+
+**Version**: 0.1.0
+**GitHub**: https://github.com/LegionIO/lex-uais
+**License**: Apache-2.0
+
+## Architecture
+
+```
+Legion::Extensions::Uais
+├── Runners/
+│   └── Registration          # register_worker, deregister_worker, check_registration, airb_status
+├── Helpers/
+│   └── Client                # Net::HTTP connection builder with build_request helper
+└── Client                    # Standalone client class (includes all runners)
+```
+
+## Key Files
+
+| Path | Purpose |
+|------|---------|
+| `lib/legion/extensions/uais.rb` | Entry point, extension registration, `default_settings` |
+| `lib/legion/extensions/uais/runners/registration.rb` | Registration logic (all 4 operations) + mock adapter + soft-warn |
+| `lib/legion/extensions/uais/helpers/client.rb` | Net::HTTP connection builder with timeout and auth |
+| `lib/legion/extensions/uais/client.rb` | Standalone `Client` class for use outside Legion framework |
+
+## Runner Methods
+
+All methods are in `Runners::Registration` and return hashes with status info. On failure, they log warnings via `soft_warn` and return error hashes instead of raising.
+
+| Method | Args | Notes |
+|--------|------|-------|
+| `register_worker` | `worker_id:, name:, owner_msid:, extension_name:, **opts` | opts: `risk_tier:`, `team:`, `business_role:` |
+| `deregister_worker` | `worker_id:, reason: nil` | |
+| `check_registration` | `worker_id:` | |
+| `airb_status` | `worker_id:` | AIRB approval status |
+
+## Mock Mode
+
+Mock mode is active when `mock: true` (default) or `base_url` is nil. All operations return success with `mock: true` in the response hash.
+
+## Notes
+
+- `default_settings` defines `mock: true`, `base_url: nil`, `timeout: 30`
+- Uses Net::HTTP directly (no Faraday dependency)
+- `soft_warn` logs via `Legion::Logging.warn` if available; never raises
+- Standalone `Client` class auto-enables mock when `base_url` is nil
+
+## Dependencies
+
+| Gem | Purpose |
+|-----|---------|
+| `legion-json` | JSON serialization |
+| `legion-logging` | Logging (optional, for soft-warn) |
+| `legion-settings` | Configuration management |
+
+## Testing
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+---
+
+**Maintained By**: Matthew Iverson (@Esity)

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'rspec_junit_formatter'
+  gem 'rubocop'
+  gem 'simplecov'
+
+  gem 'legion-cache'
+  gem 'legion-crypt'
+  gem 'legion-data'
+  gem 'legion-transport'
+end

data/README.md

@@ -0,0 +1,69 @@
+# lex-uais
+
+LegionIO extension for United AI Studio (UAIS) agent registration. Provides a client for registering, deregistering, and checking Digital Worker registration status with the UAIS platform.
+
+## Features
+
+- Register/deregister Digital Workers with UAIS
+- Check registration status and AIRB approval
+- Mock adapter (default) for development and testing
+- Soft-warn enforcement: failures log warnings but never block operations
+- Standalone `Client` class for use outside the Legion framework
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'lex-uais'
+```
+
+## Usage
+
+### Standalone Client
+
+```ruby
+require 'legion/extensions/uais/client'
+
+# Mock mode (default when no base_url)
+client = Legion::Extensions::Uais::Client.new
+result = client.register_worker(worker_id: 'w-123', name: 'InvoiceBot', owner_msid: 'ms123', extension_name: 'lex-invoice')
+
+# Live mode
+client = Legion::Extensions::Uais::Client.new(base_url: 'https://api.uais.uhg.com', api_key: 'key')
+result = client.register_worker(worker_id: 'w-123', name: 'InvoiceBot', owner_msid: 'ms123', extension_name: 'lex-invoice')
+```
+
+### Within Legion Framework
+
+The extension is auto-discovered via the `lex-*` naming convention. Configure via settings:
+
+```yaml
+uais:
+  options:
+    base_url: https://api.uais.uhg.com
+    api_key: <vault-sourced>
+    mock: false
+    timeout: 30
+```
+
+## Runner Methods
+
+| Method | Description |
+|--------|-------------|
+| `register_worker` | Register a Digital Worker with UAIS |
+| `deregister_worker` | Deregister a worker |
+| `check_registration` | Check if a worker is registered |
+| `airb_status` | Check AIRB approval status |
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+Apache-2.0

data/lex-uais.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/uais/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-uais'
+  spec.version       = Legion::Extensions::Uais::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['legionio@esity.info']
+
+  spec.summary       = 'LegionIO extension for United AI Studio (UAIS) registration'
+  spec.description   = 'UAIS agent registration client with mock adapter and soft-warn enforcement'
+  spec.homepage      = 'https://github.com/LegionIO/lex-uais'
+  spec.license       = 'Apache-2.0'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.metadata['homepage_uri']    = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri']   = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files         = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'legion-json',      '>= 1.2'
+  spec.add_dependency 'legion-logging',   '>= 0.3'
+  spec.add_dependency 'legion-settings',  '>= 0.3'
+end

data/lib/legion/extensions/uais/client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Uais
+      class Client
+        include Helpers::Client
+        include Runners::Registration
+
+        attr_reader :opts
+
+        def initialize(base_url: nil, api_key: nil, timeout: 30, mock: nil, **extra)
+          mock = base_url.nil? if mock.nil?
+          @opts = { base_url: base_url, api_key: api_key, timeout: timeout, mock: mock, **extra }
+        end
+
+        def settings
+          { options: @opts }
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/uais/helpers/client.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module Legion
+  module Extensions
+    module Uais
+      module Helpers
+        module Client
+          def connection(base_url:, api_key: nil, timeout: 30, **_opts)
+            uri = URI.parse(base_url)
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = uri.scheme == 'https'
+            http.open_timeout = timeout
+            http.read_timeout = timeout
+            http.instance_variable_set(:@_api_key, api_key)
+
+            def http.api_key
+              @_api_key
+            end
+
+            http
+          end
+
+          def build_request(method, path, body: nil, api_key: nil)
+            klass = case method.to_s.downcase
+                    when 'post'   then Net::HTTP::Post
+                    when 'put'    then Net::HTTP::Put
+                    when 'get'    then Net::HTTP::Get
+                    when 'delete' then Net::HTTP::Delete
+                    else
+                      raise ArgumentError, "unsupported HTTP method: #{method}"
+                    end
+
+            req = klass.new(path)
+            req['Content-Type'] = 'application/json'
+            req['Authorization'] = "Bearer #{api_key}" if api_key
+            req.body = Legion::JSON.dump(body) if body
+            req
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/uais/runners/registration.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Uais
+      module Runners
+        module Registration
+          def register_worker(worker_id:, name:, owner_msid:, extension_name:, **opts)
+            return mock_register(worker_id, name) if mock_mode?
+
+            payload = {
+              worker_id:      worker_id,
+              name:           name,
+              owner_msid:     owner_msid,
+              extension_name: extension_name,
+              risk_tier:      opts[:risk_tier],
+              team:           opts[:team],
+              business_role:  opts[:business_role]
+            }.compact
+
+            response = uais_post('/api/v1/agents', payload)
+            { registered: response[:success], uais_id: response[:data]&.dig(:id), worker_id: worker_id }
+          rescue StandardError => e
+            soft_warn("UAIS registration failed for #{worker_id}: #{e.message}")
+            { registered: false, worker_id: worker_id, error: e.message }
+          end
+
+          def deregister_worker(worker_id:, reason: nil)
+            return mock_deregister(worker_id) if mock_mode?
+
+            response = uais_post("/api/v1/agents/#{worker_id}/deregister", { reason: reason })
+            { deregistered: response[:success], worker_id: worker_id }
+          rescue StandardError => e
+            soft_warn("UAIS deregistration failed for #{worker_id}: #{e.message}")
+            { deregistered: false, worker_id: worker_id, error: e.message }
+          end
+
+          def check_registration(worker_id:)
+            return { registered: true, mock: true } if mock_mode?
+
+            response = uais_get("/api/v1/agents/#{worker_id}")
+            { registered: response[:success], data: response[:data] }
+          rescue StandardError => e
+            soft_warn("UAIS registration check failed for #{worker_id}: #{e.message}")
+            { registered: false, error: e.message }
+          end
+
+          def airb_status(worker_id:)
+            return { status: 'approved', mock: true } if mock_mode?
+
+            response = uais_get("/api/v1/agents/#{worker_id}/airb")
+            { status: response.dig(:data, :status), data: response[:data] }
+          rescue StandardError => e
+            soft_warn("UAIS AIRB check failed for #{worker_id}: #{e.message}")
+            { status: 'unknown', error: e.message }
+          end
+
+          private
+
+          def uais_settings
+            settings[:options] || {}
+          end
+
+          def uais_post(path, body)
+            conn = connection(**uais_connection_opts)
+            req = build_request(:post, path, body: body, api_key: uais_settings[:api_key])
+            resp = conn.request(req)
+            parse_response(resp)
+          end
+
+          def uais_get(path)
+            conn = connection(**uais_connection_opts)
+            req = build_request(:get, path, api_key: uais_settings[:api_key])
+            resp = conn.request(req)
+            parse_response(resp)
+          end
+
+          def uais_connection_opts
+            {
+              base_url: uais_settings[:base_url] || 'https://api.uais.uhg.com',
+              api_key:  uais_settings[:api_key],
+              timeout:  uais_settings[:timeout] || 30
+            }
+          end
+
+          def parse_response(resp)
+            body = begin
+              Legion::JSON.load(resp.body)
+            rescue StandardError
+              {}
+            end
+            { success: resp.is_a?(Net::HTTPSuccess), status: resp.code.to_i, data: body }
+          end
+
+          def mock_mode?
+            uais_settings[:mock] == true || uais_settings[:base_url].nil?
+          end
+
+          def mock_register(worker_id, name)
+            soft_warn("UAIS mock mode: register #{name} (#{worker_id})")
+            { registered: true, mock: true, worker_id: worker_id }
+          end
+
+          def mock_deregister(worker_id)
+            soft_warn("UAIS mock mode: deregister #{worker_id}")
+            { deregistered: true, mock: true, worker_id: worker_id }
+          end
+
+          def soft_warn(message)
+            Legion::Logging.warn("[lex-uais] #{message}") if defined?(Legion::Logging)
+          end
+
+          include Helpers::Client if defined?(Helpers::Client)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/uais/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Uais
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/uais.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/uais/version'
+require 'legion/extensions/uais/helpers/client'
+require 'legion/extensions/uais/runners/registration'
+
+module Legion
+  module Extensions
+    module Uais
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+
+      def self.default_settings
+        {
+          options: {
+            base_url: nil,
+            api_key:  nil,
+            mock:     true,
+            timeout:  30
+          }
+        }
+      end
+    end
+  end
+end

data/spec/legion/extensions/uais/client_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/uais/client'
+
+RSpec.describe Legion::Extensions::Uais::Client do
+  describe '#initialize' do
+    it 'defaults to mock mode when no base_url' do
+      client = described_class.new
+      expect(client.opts[:mock]).to be true
+    end
+
+    it 'defaults to mock mode when base_url is nil' do
+      client = described_class.new(base_url: nil)
+      expect(client.opts[:mock]).to be true
+    end
+
+    it 'disables mock when base_url is provided and mock not specified' do
+      client = described_class.new(base_url: 'https://example.com')
+      expect(client.opts[:mock]).to be false
+    end
+
+    it 'respects explicit mock: true even with base_url' do
+      client = described_class.new(base_url: 'https://example.com', mock: true)
+      expect(client.opts[:mock]).to be true
+    end
+
+    it 'stores api_key' do
+      client = described_class.new(api_key: 'test-key')
+      expect(client.opts[:api_key]).to eq('test-key')
+    end
+
+    it 'stores timeout' do
+      client = described_class.new(timeout: 60)
+      expect(client.opts[:timeout]).to eq(60)
+    end
+  end
+
+  describe '#settings' do
+    it 'wraps opts in :options key' do
+      client = described_class.new
+      expect(client.settings).to have_key(:options)
+      expect(client.settings[:options]).to eq(client.opts)
+    end
+  end
+end

data/spec/legion/extensions/uais/helpers/client_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/uais/helpers/client'
+
+RSpec.describe Legion::Extensions::Uais::Helpers::Client do
+  let(:test_class) { Class.new { include Legion::Extensions::Uais::Helpers::Client } }
+  let(:instance) { test_class.new }
+
+  describe '#connection' do
+    it 'returns a Net::HTTP instance' do
+      conn = instance.connection(base_url: 'https://example.com')
+      expect(conn).to be_a(Net::HTTP)
+    end
+
+    it 'enables SSL for https' do
+      conn = instance.connection(base_url: 'https://example.com')
+      expect(conn.use_ssl?).to be true
+    end
+
+    it 'disables SSL for http' do
+      conn = instance.connection(base_url: 'http://example.com')
+      expect(conn.use_ssl?).to be false
+    end
+
+    it 'sets timeout' do
+      conn = instance.connection(base_url: 'https://example.com', timeout: 15)
+      expect(conn.open_timeout).to eq(15)
+      expect(conn.read_timeout).to eq(15)
+    end
+  end
+
+  describe '#build_request' do
+    it 'creates a POST request' do
+      req = instance.build_request(:post, '/api/v1/agents')
+      expect(req).to be_a(Net::HTTP::Post)
+    end
+
+    it 'creates a GET request' do
+      req = instance.build_request(:get, '/api/v1/agents/123')
+      expect(req).to be_a(Net::HTTP::Get)
+    end
+
+    it 'sets content type to JSON' do
+      req = instance.build_request(:post, '/test')
+      expect(req['Content-Type']).to eq('application/json')
+    end
+
+    it 'sets authorization header when api_key provided' do
+      req = instance.build_request(:get, '/test', api_key: 'my-key')
+      expect(req['Authorization']).to eq('Bearer my-key')
+    end
+
+    it 'does not set authorization without api_key' do
+      req = instance.build_request(:get, '/test')
+      expect(req['Authorization']).to be_nil
+    end
+
+    it 'serializes body as JSON' do
+      req = instance.build_request(:post, '/test', body: { name: 'TestBot' })
+      expect(req.body).to include('TestBot')
+    end
+  end
+end

data/spec/legion/extensions/uais/runners/registration_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/uais/client'
+
+RSpec.describe Legion::Extensions::Uais::Runners::Registration do
+  let(:client) { Legion::Extensions::Uais::Client.new }
+  let(:live_client) { Legion::Extensions::Uais::Client.new(base_url: 'https://api.uais.uhg.com', api_key: 'test-key', mock: false) }
+
+  describe 'mock mode' do
+    describe '#register_worker' do
+      subject(:result) do
+        client.register_worker(worker_id: 'w-123', name: 'TestBot', owner_msid: 'ms456', extension_name: 'lex-test')
+      end
+
+      it 'returns registered: true' do
+        expect(result[:registered]).to be true
+      end
+
+      it 'includes mock: true' do
+        expect(result[:mock]).to be true
+      end
+
+      it 'includes the worker_id' do
+        expect(result[:worker_id]).to eq('w-123')
+      end
+    end
+
+    describe '#deregister_worker' do
+      subject(:result) { client.deregister_worker(worker_id: 'w-123') }
+
+      it 'returns deregistered: true' do
+        expect(result[:deregistered]).to be true
+      end
+
+      it 'includes mock: true' do
+        expect(result[:mock]).to be true
+      end
+    end
+
+    describe '#check_registration' do
+      subject(:result) { client.check_registration(worker_id: 'w-123') }
+
+      it 'returns registered: true' do
+        expect(result[:registered]).to be true
+      end
+
+      it 'includes mock: true' do
+        expect(result[:mock]).to be true
+      end
+    end
+
+    describe '#airb_status' do
+      subject(:result) { client.airb_status(worker_id: 'w-123') }
+
+      it 'returns status approved' do
+        expect(result[:status]).to eq('approved')
+      end
+
+      it 'includes mock: true' do
+        expect(result[:mock]).to be true
+      end
+    end
+  end
+
+  describe 'mock_mode?' do
+    it 'is true when base_url is nil' do
+      c = Legion::Extensions::Uais::Client.new(base_url: nil)
+      expect(c.send(:mock_mode?)).to be true
+    end
+
+    it 'is true when mock is explicitly true' do
+      c = Legion::Extensions::Uais::Client.new(base_url: 'https://example.com', mock: true)
+      expect(c.send(:mock_mode?)).to be true
+    end
+
+    it 'is false when base_url is set and mock is false' do
+      c = Legion::Extensions::Uais::Client.new(base_url: 'https://example.com', mock: false)
+      expect(c.send(:mock_mode?)).to be false
+    end
+  end
+
+  describe 'soft-warn on failure' do
+    it 'returns error hash instead of raising on register failure' do
+      allow(live_client).to receive(:connection).and_raise(Errno::ECONNREFUSED)
+      result = live_client.register_worker(worker_id: 'w-fail', name: 'FailBot', owner_msid: 'ms789', extension_name: 'lex-fail')
+      expect(result[:registered]).to be false
+      expect(result[:error]).to include('Connection refused')
+    end
+
+    it 'returns error hash instead of raising on deregister failure' do
+      allow(live_client).to receive(:connection).and_raise(Errno::ECONNREFUSED)
+      result = live_client.deregister_worker(worker_id: 'w-fail')
+      expect(result[:deregistered]).to be false
+      expect(result[:error]).to include('Connection refused')
+    end
+
+    it 'returns error hash instead of raising on check_registration failure' do
+      allow(live_client).to receive(:connection).and_raise(Errno::ECONNREFUSED)
+      result = live_client.check_registration(worker_id: 'w-fail')
+      expect(result[:registered]).to be false
+      expect(result[:error]).to include('Connection refused')
+    end
+
+    it 'returns error hash instead of raising on airb_status failure' do
+      allow(live_client).to receive(:connection).and_raise(Errno::ECONNREFUSED)
+      result = live_client.airb_status(worker_id: 'w-fail')
+      expect(result[:status]).to eq('unknown')
+      expect(result[:error]).to include('Connection refused')
+    end
+  end
+end

data/spec/legion/extensions/uais_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Uais do
+  it 'has a version number' do
+    expect(Legion::Extensions::Uais::VERSION).not_to be_nil
+  end
+
+  it 'version is a string' do
+    expect(Legion::Extensions::Uais::VERSION).to be_a(String)
+  end
+
+  describe '.default_settings' do
+    subject(:settings) { described_class.default_settings }
+
+    it 'returns a hash with options' do
+      expect(settings).to be_a(Hash)
+      expect(settings).to have_key(:options)
+    end
+
+    it 'defaults mock to true' do
+      expect(settings[:options][:mock]).to be true
+    end
+
+    it 'defaults base_url to nil' do
+      expect(settings[:options][:base_url]).to be_nil
+    end
+
+    it 'defaults timeout to 30' do
+      expect(settings[:options][:timeout]).to eq(30)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+# Minimal stubs for Legion framework modules used by lex-uais
+module Legion
+  module Extensions
+    module Helpers
+      module Lex; end
+    end
+  end
+
+  module Logging
+    def self.warn(msg); end
+    def self.info(msg); end
+    def self.debug(msg); end
+  end
+
+  module Settings
+    def self.[](_key)
+      nil
+    end
+
+    def self.dig(*_keys)
+      nil
+    end
+
+    def self.merge_settings(key, defaults); end
+  end
+
+  module JSON
+    def self.dump(obj)
+      require 'json'
+      ::JSON.generate(obj)
+    end
+
+    def self.load(str)
+      require 'json'
+      ::JSON.parse(str, symbolize_names: true)
+    end
+  end
+end
+
+require 'legion/extensions/uais'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: lex-uais
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: UAIS agent registration client with mock adapter and soft-warn enforcement
+email:
+- legionio@esity.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/CODEOWNERS"
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- Gemfile
+- README.md
+- lex-uais.gemspec
+- lib/legion/extensions/uais.rb
+- lib/legion/extensions/uais/client.rb
+- lib/legion/extensions/uais/helpers/client.rb
+- lib/legion/extensions/uais/runners/registration.rb
+- lib/legion/extensions/uais/version.rb
+- spec/legion/extensions/uais/client_spec.rb
+- spec/legion/extensions/uais/helpers/client_spec.rb
+- spec/legion/extensions/uais/runners/registration_spec.rb
+- spec/legion/extensions/uais_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-uais
+licenses:
+- Apache-2.0
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/LegionIO/lex-uais
+  source_code_uri: https://github.com/LegionIO/lex-uais
+  changelog_uri: https://github.com/LegionIO/lex-uais/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LegionIO extension for United AI Studio (UAIS) registration
+test_files: []