legion-tty 0.4.39 → 0.4.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a46889a85e5da8000964e9ac91d0c8e8fba67591fc12ca4bc8a4057339ed09b
-  data.tar.gz: d769157e7b76054bc01148650474b0e621a22173428628ce2edf41e2c58aafc8
+  metadata.gz: 60e92790f0f6281b48346af3972e2631f1952b3b68f3d51922aa52da8682cfc9
+  data.tar.gz: 85491c70182ced9142b483c4edd903f3e5948bac1544c01cba69a86f565d2483
 SHA512:
-  metadata.gz: cfb3a079a43835daf8cb922627ccb2f19e36c9fcfd0577f9cfa9a468f38d0ff1f658eaaeeda82ff202b6213013442e798cca11e9b61ca544ce171173ada7ce8e
-  data.tar.gz: 4bc9d5d5e2b7173740d4d1a72193e31d77c7bd22bfa745cd39861704804d2f78489dafc915c5a35b916252a554b80df685b4e0bb6136f0cc1bef356b24e57a0f
+  metadata.gz: 757d74c3e7e0d7711cc9bb0cb410c145e7e8ca31d484d62ad53160df64c34205be19d6eb0fa91d7aede125af63ff1d005f596ea10c285fcbdc97adb5c74eee19
+  data.tar.gz: df6acc61f03cfc4631ccd28eaea40813314aadc8211497e857507ac7453ab700952bf6588a4d34016d3d5196651680583a293ff1bfba204101408b62a5c7fd4d

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # 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

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/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/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.4.39'
+    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.39
+  version: 0.4.40
 platform: ruby
 authors:
 - Esity