legion-tty 0.4.38 → 0.4.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5015163992ac8b889c19088f2caa60b3e80fc09445c7feb27085f4c39c0857a5
-  data.tar.gz: 6eadf44a9366956867b097b1a10769ae18b01d1a644daae91c3ea5fade6681b3
+  metadata.gz: 60e92790f0f6281b48346af3972e2631f1952b3b68f3d51922aa52da8682cfc9
+  data.tar.gz: 85491c70182ced9142b483c4edd903f3e5948bac1544c01cba69a86f565d2483
 SHA512:
-  metadata.gz: 914de3d2b07691224655ac5b1dd4bb7b1dd9b88083fde6a0b719c9398a654c0b91640c621ea88865d11ad8b737909af0a24dcbae9ff1e4d200be8eda58d14af6
-  data.tar.gz: dd740544c87c71fa843e72ad602f49d029cd485f16d4b2532e55927ce33b2019042772812f59281aa00633c75af9ed5b3ce0f89c84070bd250ce51c27db304bf
+  metadata.gz: 757d74c3e7e0d7711cc9bb0cb410c145e7e8ca31d484d62ad53160df64c34205be19d6eb0fa91d7aede125af63ff1d005f596ea10c285fcbdc97adb5c74eee19
+  data.tar.gz: df6acc61f03cfc4631ccd28eaea40813314aadc8211497e857507ac7453ab700952bf6588a4d34016d3d5196651680583a293ff1bfba204101408b62a5c7fd4d

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.4.40] - 2026-03-28
+
+### Changed
+- All LLM calls in the chat screen now route exclusively through the LegionIO daemon API (`POST /api/llm/inference`) via `Legion::TTY::DaemonClient.inference`
+- Removed soft fallback to raw RubyLLM (`send_via_direct` / `@llm_chat.ask`) — if the daemon is not running, a clear error is displayed: "LegionIO daemon is not running. Start it with: legionio start"
+- Fixed `send_via_daemon`: was calling `Legion::LLM.ask` (which never returns `{status: :done}`) and falling through to direct on every call; now calls `DaemonClient.inference` with the full conversation history
+- Fixed `daemon_available?`: was checking `Legion::LLM::DaemonClient` (an unrelated module); now calls `Legion::TTY::DaemonClient.available?` directly
+- `try_settings_llm` in `App` no longer creates a raw `Legion::LLM.chat` session; daemon availability is logged instead
+- System prompt is now injected per-request as part of the messages array sent to `/api/llm/inference`, not pre-set on a session object
+- Added `DaemonClient.inference` method: `POST /api/llm/inference` with messages array, tools, model, provider; returns `{status: :ok/:error/:unavailable, data:}`
+- Added `build_inference_messages`: assembles system + conversation history + current message for the inference call
+- Added `track_inference_tokens`: tracks input/output tokens from the `data` hash returned by `/api/llm/inference`
+
+## [0.4.39] - 2026-03-28
+
+### Fixed
+- Onboarding wizard now installs GAIA cognitive extension gems when waking GAIA: after the daemon starts (or is already running), `offer_gaia_gems` checks for the 21 agentic/GAIA-tier gems via `Gem::Specification.find_by_name` and prompts the user to install any that are missing
+- `LlmProbe` now returns `:configured` status (instead of `:error`) when a provider is enabled but the ping fails (e.g. Vault-injected providers unknown to `apply_provider_config`); these providers are shown with a key icon and "configured, not validated" label and are selectable as the default when no fully-validated `:ok` providers exist
+- `LlmProbe` accepts a `wait_queue:` argument so it waits for the bootstrap config thread to complete before probing, ensuring Vault-sourced provider settings are written to `~/.legionio/settings/llm.json` first
+- `select_provider_default` falls back to `:configured` providers when no `:ok` providers exist, so Vault-resolved providers are usable as the chat default
+
 ## [0.4.38] - 2026-03-26
 
 ### Added

data/lib/legion/tty/app.rb

@@ -468,15 +468,16 @@ module Legion
       end
 
       def try_settings_llm
-        return nil unless defined?(Legion::LLM)
-
-        Legion::LLM.start unless Legion::LLM.started?
-        return nil unless Legion::LLM.started?
-
-        provider = Legion::LLM.settings[:default_provider]
-        return nil unless provider
-
-        Legion::LLM.chat(provider: provider, caller: { source: 'tty', screen: 'chat' })
+        # All LLM calls route through the LegionIO daemon API.
+        # No raw RubyLLM session is created here — nil signals "use daemon path".
+        if Legion::TTY::DaemonClient.available?
+          Legion::Logging.debug('TTY: daemon available, LLM routed through daemon') if defined?(Legion::Logging)
+        elsif defined?(Legion::Logging)
+          if defined?(Legion::Logging)
+            Legion::Logging.warn('TTY: daemon not running; LLM unavailable until daemon starts')
+          end
+        end
+        nil
       rescue StandardError => e
         Legion::Logging.warn("try_settings_llm failed: #{e.message}") if defined?(Legion::Logging)
         nil

data/lib/legion/tty/background/llm_probe.rb

@@ -4,12 +4,14 @@ module Legion
   module TTY
     module Background
       class LlmProbe
-        def initialize(logger: nil)
+        def initialize(logger: nil, wait_queue: nil)
           @log = logger
+          @wait_queue = wait_queue
         end
 
         def run_async(queue)
           Thread.new do
+            wait_for_bootstrap if @wait_queue
             result = probe_providers
             queue.push({ data: result })
           rescue StandardError => e
@@ -20,6 +22,28 @@ module Legion
 
         private
 
+        def wait_for_bootstrap
+          deadline = Time.now + 15
+          timed_out = false
+          loop do
+            break unless @wait_queue.empty?
+
+            if Time.now >= deadline
+              timed_out = true
+              break
+            end
+
+            sleep 0.2
+          end
+          if timed_out
+            @log&.log('llm_probe', 'bootstrap wait timed out')
+          else
+            @log&.log('llm_probe', 'bootstrap wait complete')
+          end
+        rescue StandardError => e
+          @log&.log('llm_probe', "bootstrap wait error: #{e.message}")
+        end
+
         def probe_providers
           require 'legion/llm'
           require 'legion/settings'
@@ -54,7 +78,7 @@ module Legion
         rescue StandardError => e
           latency = ((Time.now - start_time) * 1000).round
           Legion::Logging.debug("ping_provider #{name} failed: #{e.message}") if defined?(Legion::Logging)
-          { name: name, model: model, status: :error, latency_ms: latency, error: e.message }
+          { name: name, model: model, status: :configured, latency_ms: latency, error: e.message }
         end
       end
     end

data/lib/legion/tty/components/wizard_prompt.rb

@@ -56,10 +56,14 @@ module Legion
 
         def display_provider_results(providers)
           providers.each do |p|
-            icon = p[:status] == :ok ? "\u2705" : "\u274C"
+            icon = case p[:status]
+                   when :ok then "\u2705"
+                   when :configured then "\U0001F511"
+                   else "\u274C"
+                   end
             latency = "#{p[:latency_ms]}ms"
             label = "#{icon} #{p[:name]} (#{p[:model]}) \u2014 #{latency}"
-            label += " [#{p[:error]}]" if p[:error]
+            label += p[:status] == :configured ? ' [configured, not validated]' : " [#{p[:error]}]" if p[:error]
             @prompt.say(label)
           end
         end

data/lib/legion/tty/daemon_client.rb

@@ -10,6 +10,7 @@ module Legion
     module DaemonClient
       SUCCESS_CODES = [200, 201, 202].freeze
 
+      # rubocop:disable Metrics/ClassLength
       class << self
         def configure(daemon_url: 'http://127.0.0.1:4567', cache_file: nil, timeout: 5)
           @daemon_url = daemon_url
@@ -89,6 +90,19 @@ module Legion
           nil
         end
 
+        def inference(messages:, tools: [], model: nil, provider: nil, timeout: 120)
+          response = post_inference(messages: messages, tools: tools, model: model,
+                                    provider: provider, timeout: timeout)
+          return inference_error_result(response) unless SUCCESS_CODES.include?(response.code.to_i)
+
+          body = Legion::JSON.load(response.body)
+          data = body[:data] || body
+          { status: :ok, data: data }
+        rescue StandardError => e
+          Legion::Logging.warn("inference failed: #{e.message}") if defined?(Legion::Logging)
+          { status: :unavailable, error: { message: e.message } }
+        end
+
         def reset!
           @daemon_url = nil
           @cache_file = nil
@@ -98,6 +112,29 @@ module Legion
 
         private
 
+        def post_inference(messages:, tools:, model:, provider:, timeout:)
+          uri = URI("#{daemon_url}/api/llm/inference")
+          payload = Legion::JSON.dump({ messages: messages, tools: tools,
+                                        model: model, provider: provider }.compact)
+          http_timeout = [timeout, @timeout || 5].max
+          req = Net::HTTP::Post.new(uri)
+          req['Content-Type'] = 'application/json'
+          req.body = payload
+          Net::HTTP.start(uri.hostname, uri.port,
+                          open_timeout: @timeout || 5,
+                          read_timeout: http_timeout) { |h| h.request(req) }
+        end
+
+        def inference_error_result(response)
+          body = begin
+            Legion::JSON.load(response.body)
+          rescue StandardError
+            {}
+          end
+          err = body.dig(:error, :message) || body.dig(:data, :error, :message) || "HTTP #{response.code}"
+          { status: :error, error: { message: err } }
+        end
+
         def daemon_url
           @daemon_url || 'http://127.0.0.1:4567'
         end
@@ -119,6 +156,7 @@ module Legion
           nil
         end
       end
+      # rubocop:enable Metrics/ClassLength
     end
   end
 end

data/lib/legion/tty/screens/chat/model_commands.rb

@@ -18,33 +18,18 @@ module Legion
           end
 
           def switch_model(name)
-            unless @llm_chat
-              @message_stream.add_message(role: :system, content: 'No active LLM session.')
-              return
-            end
-
-            apply_model_switch(name)
+            @preferred_model = name
+            @status_bar.update(model: name)
+            @token_tracker.update_model(name)
+            @message_stream.add_message(role: :system,
+                                        content: "Model preference set to: #{name} (applied on next daemon request)")
           rescue StandardError => e
             Legion::Logging.warn("switch_model failed: #{e.message}") if defined?(Legion::Logging)
             @message_stream.add_message(role: :system, content: "Failed to switch model: #{e.message}")
           end
 
           def apply_model_switch(name)
-            new_chat = try_provider_switch(name)
-            if new_chat
-              @llm_chat = new_chat
-              @status_bar.update(model: name)
-              @token_tracker.update_model(name)
-              @message_stream.add_message(role: :system, content: "Switched to provider: #{name}")
-            elsif @llm_chat.respond_to?(:with_model)
-              @llm_chat.with_model(name)
-              @status_bar.update(model: name)
-              @token_tracker.update_model(name)
-              @message_stream.add_message(role: :system, content: "Model switched to: #{name}")
-            else
-              @status_bar.update(model: name)
-              @message_stream.add_message(role: :system, content: "Model set to: #{name}")
-            end
+            switch_model(name)
           end
 
           def try_provider_switch(name)
@@ -75,9 +60,8 @@ module Legion
           end
 
           def show_current_model
-            model = @llm_chat.respond_to?(:model) ? @llm_chat.model : nil
             provider = safe_config[:provider] || 'unknown'
-            info = model ? "#{model} (#{provider})" : provider
+            info = @preferred_model ? "#{@preferred_model} (#{provider})" : provider
             @message_stream.add_message(role: :system, content: "Current model: #{info}")
           end
 

data/lib/legion/tty/screens/chat.rb

@@ -73,10 +73,10 @@ module Legion
           @output = output
           @message_stream = Components::MessageStream.new
           @status_bar = Components::StatusBar.new
-          @llm_chat = app.respond_to?(:llm_chat) ? app.llm_chat : nil
+          @llm_chat = nil
           @token_tracker = Components::TokenTracker.new(
             provider: detect_provider,
-            model: @llm_chat.respond_to?(:model) ? @llm_chat.model.to_s : nil
+            model: nil
           )
           @session_store = SessionStore.new
           @session_name = 'default'
@@ -174,16 +174,14 @@ module Legion
         end
 
         def send_to_llm(message)
-          unless @llm_chat || daemon_available?
-            @message_stream.append_streaming('LLM not configured. Use /help for commands.')
+          unless daemon_available?
+            @message_stream.append_streaming(
+              'LegionIO daemon is not running. Start it with: legionio start'
+            )
             return
           end
 
-          if daemon_available?
-            send_via_daemon(message)
-          else
-            send_via_direct(message)
-          end
+          send_via_daemon(message)
         rescue StandardError => e
           Legion::Logging.error("send_to_llm failed: #{e.message}") if defined?(Legion::Logging)
           @status_bar.update(thinking: false)
@@ -239,60 +237,47 @@ module Legion
         end
 
         def setup_system_prompt
-          cfg = safe_config
-          return unless @llm_chat && cfg.is_a?(Hash) && !cfg.empty?
-
-          prompt = build_system_prompt(cfg)
-          @llm_chat.with_instructions(prompt) if @llm_chat.respond_to?(:with_instructions)
+          # System prompt is injected per-request in build_inference_messages.
+          # Nothing to do at activation time.
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def send_via_daemon(message)
-          result = Legion::LLM.ask(message: message)
+          @status_bar.update(thinking: true)
+          @streaming = true
+          @app.render_frame if @app.respond_to?(:render_frame)
+
+          start_time = Time.now
+          messages = build_inference_messages(message)
+          result = Legion::TTY::DaemonClient.inference(
+            messages: messages,
+            model: @preferred_model
+          )
 
-          case result&.dig(:status)
-          when :done
+          case result[:status]
+          when :ok
+            data = result[:data] || {}
+            content = data[:content].to_s
             parser = build_tool_call_parser
-            parser.feed(result[:response])
+            parser.feed(content)
             parser.flush
-            track_daemon_tokens(result)
+            record_response_time(Time.now - start_time)
+            track_inference_tokens(data)
+            speak_response(content) if @speak_mode
           when :error
             err = result.dig(:error, :message) || 'Unknown error'
             @message_stream.append_streaming("\n[Daemon error: #{err}]")
-          else
-            send_via_direct(message)
+          when :unavailable
+            err = result.dig(:error, :message) || 'Daemon unavailable'
+            @message_stream.append_streaming(
+              "\nLegionIO daemon is not running. Start it with: legionio start\n[#{err}]"
+            )
           end
-        rescue StandardError => e
-          Legion::Logging.warn("send_via_daemon failed: #{e.message}") if defined?(Legion::Logging)
-          send_via_direct(message)
-        end
-
-        # rubocop:disable Metrics/AbcSize
-        def send_via_direct(message)
-          return unless @llm_chat
-
-          @status_bar.update(thinking: true)
-          @streaming = true
-          @app.render_frame if @app.respond_to?(:render_frame)
-          start_time = Time.now
-          response_text = +''
-          parser = build_tool_call_parser
-          response = @llm_chat.ask(message) do |chunk|
-            @status_bar.update(thinking: false)
-            if chunk.content
-              response_text << chunk.content
-              parser.feed(chunk.content)
-            end
-            @app.render_frame if @app.respond_to?(:render_frame)
-          end
-          parser.flush
-          record_response_time(Time.now - start_time)
-          @status_bar.update(thinking: false)
-          track_response_tokens(response)
-          speak_response(response_text) if @speak_mode
         ensure
+          @status_bar.update(thinking: false)
           @streaming = false
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def speak_response(text)
           return unless RUBY_PLATFORM =~ /darwin/
@@ -310,7 +295,47 @@ module Legion
         end
 
         def daemon_available?
-          !!(defined?(Legion::LLM::DaemonClient) && Legion::LLM::DaemonClient.available?)
+          Legion::TTY::DaemonClient.available?
+        rescue StandardError => e
+          Legion::Logging.debug("daemon_available? check failed: #{e.message}") if defined?(Legion::Logging)
+          false
+        end
+
+        def build_inference_messages(current_message)
+          msgs = []
+          inject_system_message(msgs)
+          inject_history_messages(msgs)
+          msgs.pop if msgs.last&.dig(:role) == 'user'
+          msgs << { role: 'user', content: current_message }
+          msgs
+        end
+
+        def inject_system_message(msgs)
+          prompt = build_system_prompt(safe_config)
+          msgs << { role: 'system', content: prompt } if prompt && !prompt.strip.empty?
+        end
+
+        def inject_history_messages(msgs)
+          @message_stream.messages.each do |m|
+            next if m[:tool_panel]
+            next unless %i[user assistant].include?(m[:role])
+
+            content = m[:content].to_s
+            next if content.strip.empty?
+
+            msgs << { role: m[:role].to_s, content: content }
+          end
+        end
+
+        def track_inference_tokens(data)
+          return unless data.is_a?(Hash) && (data[:input_tokens] || data[:output_tokens])
+
+          @token_tracker.track(
+            input_tokens: data[:input_tokens].to_i,
+            output_tokens: data[:output_tokens].to_i,
+            model: data[:model]&.to_s
+          )
+          update_status_bar_tokens
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
@@ -638,18 +663,6 @@ module Legion
           update_status_bar_tokens
         end
 
-        def track_daemon_tokens(result)
-          meta = result[:meta]
-          return unless meta.is_a?(Hash) && (meta[:tokens_in] || meta[:tokens_out])
-
-          @token_tracker.track(
-            input_tokens: meta[:tokens_in].to_i,
-            output_tokens: meta[:tokens_out].to_i,
-            model: meta[:model]&.to_s
-          )
-          update_status_bar_tokens
-        end
-
         def update_status_bar_tokens
           @status_bar.update(
             tokens: @token_tracker.total_input_tokens + @token_tracker.total_output_tokens,

data/lib/legion/tty/screens/onboarding.rb

@@ -17,6 +17,17 @@ module Legion
       class Onboarding < Base
         TYPED_DELAY = 0.05
 
+        GAIA_GEMS = %w[
+          lex-agentic-self lex-agentic-affect lex-agentic-attention
+          lex-agentic-defense lex-agentic-executive lex-agentic-homeostasis
+          lex-agentic-imagination lex-agentic-inference lex-agentic-integration
+          lex-agentic-language lex-agentic-learning lex-agentic-memory
+          lex-agentic-social
+          lex-tick lex-extinction lex-mind-growth lex-mesh
+          lex-synapse lex-react
+          legion-gaia legion-apollo
+        ].freeze
+
         def initialize(app, wizard: nil, output: $stdout, skip_rain: false)
           super(app)
           @wizard = wizard || Components::WizardPrompt.new
@@ -119,6 +130,7 @@ module Legion
 
         def select_provider_default(providers)
           working = providers.select { |p| p[:status] == :ok }
+          working = providers.select { |p| p[:status] == :configured } if working.empty?
           if working.any?
             default = @wizard.select_default_provider(working)
             sleep 0.5
@@ -139,7 +151,7 @@ module Legion
           @kerberos_probe.run_async(@kerberos_queue)
           @github_probe.run_quick_async(@github_quick_queue)
           require_relative '../background/llm_probe'
-          @llm_probe = Background::LlmProbe.new(logger: @log)
+          @llm_probe = Background::LlmProbe.new(logger: @log, wait_queue: @bootstrap_queue)
           @llm_probe.run_async(@llm_queue)
           @bootstrap_probe = Background::BootstrapConfig.new(logger: @log)
           @bootstrap_probe.run_async(@bootstrap_queue)
@@ -196,37 +208,42 @@ module Legion
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
         def run_gaia_awakening
           typed_output('Scanning for active cognition threads...')
           sleep 1.2
           @output.puts
 
-          if legionio_running?
-            typed_output('GAIA is awake.')
-            sleep 0.5
-            typed_output('Heuristic mesh: nominal.')
-            sleep 0.8
-            typed_output('Cognitive threads synchronized.')
-          else
-            typed_output('GAIA is dormant.')
-            sleep 1
-            @output.puts
-            if @wizard.confirm('Shall I wake her?')
-              started = start_legionio_daemon
-              if started
-                typed_output('... initializing cognitive substrate...')
-                sleep 1
-                typed_output('GAIA online. All systems nominal.')
-              else
-                typed_output("Could not start daemon. Run 'legionio start' manually.")
-              end
-            end
-          end
+          gaia_active = if legionio_running?
+                          typed_output('GAIA is awake.')
+                          sleep 0.5
+                          typed_output('Heuristic mesh: nominal.')
+                          sleep 0.8
+                          typed_output('Cognitive threads synchronized.')
+                          true
+                        else
+                          wake_gaia_daemon
+                        end
 
+          offer_gaia_gems if gaia_active
           @output.puts
         end
-        # rubocop:enable Metrics/AbcSize
+
+        def wake_gaia_daemon
+          typed_output('GAIA is dormant.')
+          sleep 1
+          @output.puts
+          return unless @wizard.confirm('Shall I wake her?')
+
+          started = start_legionio_daemon
+          if started
+            typed_output('... initializing cognitive substrate...')
+            sleep 1
+            typed_output('GAIA online. All systems nominal.')
+          else
+            typed_output("Could not start daemon. Run 'legionio start' manually.")
+          end
+          started
+        end
 
         def collect_background_results
           @log.log('collect', 'waiting for scanner results (10s timeout)')
@@ -392,7 +409,7 @@ module Legion
 
         def store_teams_token(result)
           require 'legion/extensions/microsoft_teams/helpers/token_cache'
-          cache = Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.new
+          cache = Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
           cache.store_delegated_token(result)
           cache.save_to_vault
         rescue StandardError => e
@@ -400,6 +417,47 @@ module Legion
           nil
         end
 
+        def offer_gaia_gems
+          missing = missing_gaia_gems
+          return if missing.empty?
+
+          @output.puts
+          typed_output("#{missing.size} cognitive extension#{'s' if missing.size != 1} not installed.")
+          @output.puts
+          return unless @wizard.confirm('Install cognitive extensions?')
+
+          install_gaia_gems(missing)
+        end
+
+        def missing_gaia_gems
+          GAIA_GEMS.reject do |gem_name|
+            Gem::Specification.find_by_name(gem_name)
+            true
+          rescue Gem::LoadError
+            false
+          end
+        end
+
+        def install_gaia_gems(gems)
+          failed = []
+          gems.each do |gem_name|
+            typed_output("  installing #{gem_name}...")
+            @output.puts
+            Gem.install(gem_name)
+          rescue StandardError => e
+            @log.log('gaia_gems', "failed to install #{gem_name}: #{e.message}")
+            typed_output("  failed: #{gem_name}")
+            @output.puts
+            failed << gem_name
+          end
+          if failed.empty?
+            typed_output('Cognitive extensions installed.')
+          else
+            typed_output("Cognitive extensions installed with #{failed.size} failure#{'s' if failed.size != 1}.")
+          end
+          @output.puts
+        end
+
         def detect_gem_available?
           require 'legion/extensions/detect'
           true

data/lib/legion/tty/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.4.38'
+    VERSION = '0.4.40'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-tty
 version: !ruby/object:Gem::Version
-  version: 0.4.38
+  version: 0.4.40
 platform: ruby
 authors:
 - Esity