legionio 1.6.21 → 1.6.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d50e1efc9398c0e2d380c7a921e2ccc8b6e6db3a142d4f4a700ff536555a2e4
-  data.tar.gz: e44d47e0c4d04362d9a35c6ad6953d0b4a42a5f0f2225dd0420e7f2d1c544ad4
+  metadata.gz: 68888d98222b99e6e88670e8df81245d312dbed7c5f04d59a0cb79e592d65e47
+  data.tar.gz: be305f5229f73ad9c28e76a87c5353afac7edfbe8764284db03e34d727af1ef8
 SHA512:
-  metadata.gz: f4cc63f869d21abc423f7836a25b91f62a815d01d1972004b85728be0b969e332a5f95c9172ab6177f3759e837b6e40bbb30afba1ecd3a817cd5088fff4c675b
-  data.tar.gz: 719f9a8e3d316937be26ed610b7ba86c653317b476b271d821591fecf5ff8157c02788b03df1468c7fe3af19d76ec1a55cf48312d911a502e30873c51d378bb0
+  metadata.gz: 180fc2adda6a37c44accfddd5c25099bab8568462ec58c99f51ccf58203d62d65813831ff569cfcd729524566be12b2c037c6df184efcf1514d9a9bd75964698
+  data.tar.gz: d5f1b84b9c562df8766b20923ebec48215b78b28e600744e9b210578a311138df4ffef221f8bb42520272fc71bff8b3041420765d7d876c8a634146927e55b15

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [1.6.22] - 2026-03-27
+
+### Added
+- `POST /api/llm/inference` daemon endpoint: accepts a full messages array plus optional tool schemas, runs a single LLM completion pass, and returns `{ content, tool_calls, stop_reason, model, input_tokens, output_tokens }` — the client owns the tool execution loop
+- `Legion::CLI::Chat::DaemonChat` adapter: drop-in replacement for the `RubyLLM::Chat` object that routes all inference through the daemon, executes tool calls locally, and loops until the LLM produces a final text response
+- `spec/legion/api/llm_inference_spec.rb`: 12 examples covering the new `/api/llm/inference` endpoint
+- `spec/legion/cli/chat/daemon_chat_spec.rb`: 25 examples covering `DaemonChat` initialization, tool registration, tool execution loop, streaming, and error handling
+
+### Changed
+- `legion chat setup_connection`: replaced `Connection.ensure_llm` (local LLM boot) with a daemon availability check via `Legion::LLM::DaemonClient.available?` — **hard fails with a descriptive error if the daemon is not running**
+- `legion chat create_chat`: now returns a `DaemonChat` instance instead of a direct `RubyLLM::Chat` object; all LLM calls route through the daemon
+
 ## [1.6.21] - 2026-03-27
 
 ### Added

data/lib/legion/api/llm.rb

@@ -43,6 +43,8 @@ module Legion
         end
 
         def self.register_chat(app) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          register_inference(app)
+
           app.post '/api/llm/chat' do # rubocop:disable Metrics/BlockLength
             Legion::Logging.debug "API: POST /api/llm/chat params=#{params.keys}"
             require_llm!
@@ -163,6 +165,75 @@ module Legion
           end
         end
 
+        def self.register_inference(app) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          app.post '/api/llm/inference' do # rubocop:disable Metrics/BlockLength
+            require_llm!
+            body = parse_request_body
+            validate_required!(body, :messages)
+
+            messages = body[:messages]
+            tools    = body[:tools] || []
+            model    = body[:model]
+            provider = body[:provider]
+
+            unless messages.is_a?(Array)
+              halt 400, { 'Content-Type' => 'application/json' },
+                   Legion::JSON.dump({ error: { code: 'invalid_messages', message: 'messages must be an array' } })
+            end
+
+            session = Legion::LLM.chat(
+              model:    model,
+              provider: provider,
+              caller:   { source: 'api', path: request.path }
+            )
+
+            unless tools.empty?
+              tool_declarations = tools.map do |t|
+                ts = t.respond_to?(:transform_keys) ? t.transform_keys(&:to_sym) : t
+                tname = ts[:name].to_s
+                tdesc = ts[:description].to_s
+                tparams = ts[:parameters] || {}
+                Class.new do
+                  define_singleton_method(:tool_name) { tname }
+                  define_singleton_method(:description)  { tdesc }
+                  define_singleton_method(:parameters)   { tparams }
+                  define_method(:call) { |**_| raise NotImplementedError, "#{tname} executes client-side only" }
+                end
+              end
+              session.with_tools(*tool_declarations)
+            end
+
+            messages.each { |m| session.add_message(m) }
+
+            last_user = messages.select { |m| (m[:role] || m['role']).to_s == 'user' }.last
+            prompt    = (last_user || {})[:content] || (last_user || {})['content'] || ''
+
+            response = session.ask(prompt)
+
+            tc_list = if response.respond_to?(:tool_calls) && response.tool_calls
+                        Array(response.tool_calls).map do |tc|
+                          {
+                            id:        tc.respond_to?(:id) ? tc.id : nil,
+                            name:      tc.respond_to?(:name) ? tc.name : tc.to_s,
+                            arguments: tc.respond_to?(:arguments) ? tc.arguments : {}
+                          }
+                        end
+                      end
+
+            json_response({
+                            content:       response.content,
+                            tool_calls:    tc_list,
+                            stop_reason:   response.respond_to?(:stop_reason) ? response.stop_reason : nil,
+                            model:         session.model.to_s,
+                            input_tokens:  response.respond_to?(:input_tokens) ? response.input_tokens : nil,
+                            output_tokens: response.respond_to?(:output_tokens) ? response.output_tokens : nil
+                          }, status_code: 200)
+          rescue StandardError => e
+            Legion::Logging.error "[api/llm/inference] #{e.class}: #{e.message}" if defined?(Legion::Logging)
+            json_response({ error: { code: 'inference_error', message: e.message } }, status_code: 500)
+          end
+        end
+
         def self.register_providers(app)
           app.get '/api/llm/providers' do
             require_llm!
@@ -190,7 +261,7 @@ module Legion
         end
 
         class << self
-          private :register_chat, :register_providers
+          private :register_chat, :register_inference, :register_providers
         end
       end
     end

data/lib/legion/cli/chat/daemon_chat.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'legion/cli/chat_command'
+
+begin
+  require 'legion/llm/daemon_client'
+rescue LoadError
+  # legion-llm not yet loaded; DaemonClient must be defined before DaemonChat#ask is called.
+end
+
+module Legion
+  module CLI
+    class Chat
+      # Daemon-backed chat adapter. Matches the interface that Session expects
+      # from a chat object (ask, with_tools, with_instructions, on_tool_call,
+      # on_tool_result, model, add_message, reset_messages!, with_model).
+      #
+      # All LLM inference is routed through the running daemon via
+      # POST /api/llm/inference. Tool execution runs locally on the client
+      # machine — the daemon returns tool_call requests and the client
+      # executes them and loops.
+      class DaemonChat
+        # Minimal response-like object returned from ask.
+        # Responds to the same interface Session#send_message reads.
+        Response = Struct.new(:content, :input_tokens, :output_tokens, :model)
+
+        # Minimal model object responding to .id (used by Session#model_id).
+        ModelInfo = Struct.new(:id) do
+          def to_s
+            id.to_s
+          end
+        end
+
+        attr_reader :model
+
+        def initialize(model: nil, provider: nil)
+          @model    = ModelInfo.new(id: model)
+          @provider = provider
+          @messages = []
+          @tools    = []
+          @instructions = nil
+          @on_tool_call   = nil
+          @on_tool_result = nil
+        end
+
+        # Sets the system prompt. Returns self for chaining.
+        def with_instructions(prompt)
+          @instructions = prompt
+          self
+        end
+
+        # Registers tool classes for local execution and schema forwarding.
+        # Returns self for chaining.
+        def with_tools(*tools)
+          @tools = tools.flatten
+          self
+        end
+
+        # Switches the active model. Returns self for chaining.
+        def with_model(model_id)
+          @model = ModelInfo.new(id: model_id)
+          self
+        end
+
+        # Stores a tool_call callback invoked before each local tool execution.
+        def on_tool_call(&block)
+          @on_tool_call = block
+        end
+
+        # Stores a tool_result callback invoked after each local tool execution.
+        def on_tool_result(&block)
+          @on_tool_result = block
+        end
+
+        # Appends a message to the conversation history directly (used by
+        # slash commands /fetch, /search, /agent, etc. that inject context).
+        def add_message(role:, content:)
+          @messages << { role: role.to_s, content: content }
+        end
+
+        # Clears all conversation history (used by /clear slash command).
+        def reset_messages!
+          @messages = []
+        end
+
+        # Sends a message through the daemon inference loop.
+        # Executes any tool_calls locally and loops until the LLM stops.
+        # Yields response-like chunks for streaming display (Phase 1: single chunk).
+        # Returns a Response object compatible with Session#send_message.
+        def ask(message, &on_chunk)
+          @messages << { role: 'user', content: message }
+
+          loop do
+            result = call_daemon_inference
+
+            raise CLI::Error, "Daemon inference error: #{result[:error]}" if result[:status] == :error
+            raise CLI::Error, 'Daemon is unavailable' if result[:status] == :unavailable
+
+            data = extract_data(result)
+
+            if data[:tool_calls]&.any?
+              execute_tool_calls(data[:tool_calls], data[:content])
+            else
+              on_chunk&.call(Response.new(content: data[:content]))
+              @messages << { role: 'assistant', content: data[:content] }
+              return build_response(data)
+            end
+          end
+        end
+
+        private
+
+        def call_daemon_inference
+          Legion::LLM::DaemonClient.inference(
+            messages: build_messages,
+            tools:    build_tool_schemas,
+            model:    @model.id,
+            provider: @provider
+          )
+        end
+
+        def extract_data(result)
+          # DaemonClient.inference returns { status:, data: { content:, tool_calls:, ... } }
+          data = result[:data] || result[:body] || {}
+          data.is_a?(Hash) ? data : {}
+        end
+
+        def build_messages
+          msgs = []
+          msgs << { role: 'system', content: @instructions } if @instructions
+          msgs + @messages
+        end
+
+        def build_tool_schemas
+          @tools.map do |tool|
+            {
+              name:        tool_name(tool),
+              description: tool_description(tool),
+              parameters:  tool_parameters(tool)
+            }
+          end
+        end
+
+        def tool_name(tool)
+          if tool.respond_to?(:tool_name)
+            tool.tool_name
+          else
+            tool.name.to_s.split('::').last.gsub(/([A-Z])/) do
+              "_#{::Regexp.last_match(1).downcase}"
+            end.delete_prefix('_')
+          end
+        end
+
+        def tool_description(tool)
+          tool.respond_to?(:description) ? tool.description : ''
+        end
+
+        def tool_parameters(tool)
+          tool.respond_to?(:parameters) ? tool.parameters : {}
+        end
+
+        def execute_tool_calls(tool_calls, assistant_content)
+          # Record the assistant turn with tool_calls before appending results.
+          @messages << { role: 'assistant', content: assistant_content, tool_calls: tool_calls }
+
+          tool_calls.each do |tc|
+            tc = tc.transform_keys(&:to_sym) if tc.respond_to?(:transform_keys)
+            tc_obj = build_tool_call_object(tc)
+
+            @on_tool_call&.call(tc_obj)
+
+            result_text = run_tool(tc)
+
+            result_obj = build_tool_result_object(result_text)
+            @on_tool_result&.call(result_obj)
+
+            @messages << {
+              role:         'tool',
+              tool_call_id: tc[:id] || tc[:tool_call_id],
+              content:      result_text.to_s
+            }
+          end
+        end
+
+        def build_tool_call_object(tool_call)
+          Struct.new(:name, :arguments, :id).new(
+            name:      tool_call[:name].to_s,
+            arguments: (tool_call[:arguments] || tool_call[:input] || {}).transform_keys(&:to_sym),
+            id:        tool_call[:id] || tool_call[:tool_call_id]
+          )
+        end
+
+        def build_tool_result_object(text)
+          Struct.new(:content).new(content: text.to_s)
+        end
+
+        def run_tool(tool_call)
+          name      = tool_call[:name].to_s
+          arguments = (tool_call[:arguments] || tool_call[:input] || {}).transform_keys(&:to_sym)
+
+          tool_class = @tools.find { |t| tool_name(t) == name }
+          return "Unknown tool: #{name}" unless tool_class
+
+          tool_class.call(**arguments)
+        rescue StandardError => e
+          "Tool error (#{name}): #{e.message}"
+        end
+
+        def build_response(data)
+          Response.new(
+            content:       data[:content],
+            input_tokens:  data[:input_tokens],
+            output_tokens: data[:output_tokens],
+            model:         ModelInfo.new(id: data[:model] || @model.id)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/chat_command.rb

@@ -176,7 +176,14 @@ module Legion
         def setup_connection
           Connection.config_dir = options[:config_dir] if options[:config_dir]
           Connection.log_level = options[:verbose] ? 'debug' : 'error'
-          Connection.ensure_llm
+          Connection.ensure_settings
+
+          require 'legion/llm/daemon_client'
+          return if Legion::LLM::DaemonClient.available?
+
+          raise CLI::Error,
+                "LegionIO daemon is not running. Start it with: legionio start\n  " \
+                'All LLM requests must route through the daemon.'
         end
 
         def setup_notification_bridge
@@ -237,13 +244,13 @@ module Legion
         end
 
         def create_chat
-          opts = {}
-          opts[:model]    = options[:model] || chat_setting(:model)
-          opts[:provider] = (options[:provider] || chat_setting(:provider))&.to_sym
-          opts.compact!
-
+          require 'legion/cli/chat/daemon_chat'
           require 'legion/cli/chat/tool_registry'
-          chat = Legion::LLM.chat(**opts, caller: { source: 'cli', command: 'chat' })
+
+          chat = Chat::DaemonChat.new(
+            model:    options[:model] || chat_setting(:model),
+            provider: (options[:provider] || chat_setting(:provider))&.to_sym
+          )
           chat.with_tools(*Chat::ToolRegistry.all_tools)
           chat
         end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.6.21'
+  VERSION = '1.6.22'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.21
+  version: 1.6.22
 platform: ruby
 authors:
 - Esity
@@ -524,6 +524,7 @@ files:
 - lib/legion/cli/chat/checkpoint.rb
 - lib/legion/cli/chat/context.rb
 - lib/legion/cli/chat/context_manager.rb
+- lib/legion/cli/chat/daemon_chat.rb
 - lib/legion/cli/chat/extension_tool.rb
 - lib/legion/cli/chat/extension_tool_loader.rb
 - lib/legion/cli/chat/markdown_renderer.rb