legion-llm 0.5.22 → 0.5.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e7ff9c35609294ace1f203076485aaba0a811ba0adbe7d01197ce91de7a06ea
-  data.tar.gz: c493d891ded32632daf9b7e367fa115efc9903cc63d408c8c0799bb8bc242ca1
+  metadata.gz: 7faa875219df27f00724444b192db231e6ef9f0b9a56da041791fbec1a17abb0
+  data.tar.gz: 271946a65933ed5366a9240490f4ba2df08f9a5c70200ab3b2605d413f6da611
 SHA512:
-  metadata.gz: 2cd3766d938ba6814f2a14af190441a0d9b0e011538da22744729b678313ff03045fc84ae4e1ecab7dcff9ac31a1d4d92afdff25d3b5e7ca322a0303ef54c0fa
-  data.tar.gz: 3a03dd436e31b0d02290e23af4cadc755136c89321af205a83c0c18dac4cac9a8f320875a578ac6405dafd409a0b3bc516431d1dff34670731ab803618df36ae
+  metadata.gz: 5b75a996f84fa52a56e2dd145ae411007e7b0e82ebbf4c3ebf472d3368c8fb9647c311de67eb3500861c2758ba2c62ae7d90c7f8540c2080625ee99ba40d21c2
+  data.tar.gz: d390c9821b76cca8889c46a5f1999408de60dadb5d0c6db05c3fa7b0e68faa152bd557b9e19e38897b5ff52af8a05be26f74f0dc32a10ea09a282247a62f0c60

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.5.24] - 2026-03-31
+
+### Added
+- `DaemonClient.inference` accepts optional `caller:` and `conversation_id:` kwargs, forwarded in POST body
+- `/api/llm/inference` route accepts `caller` and `conversation_id` from POST body, forwards to `Legion::LLM.chat`
+
+## [0.5.23] - 2026-03-31
+
+### Added
+- `Hooks::Reciprocity` — after_chat hook that records a `:given` social exchange event via `Social::Social::Client#record_exchange` when a caller with identity receives an LLM response; silently no-ops when social extension or identity is absent
+- Partner context enrichment in `Pipeline::Steps::GaiaAdvisory` (step 7) — when the caller identity is registered as a partner in `Legion::Gaia::BondRegistry`, the advisory data is enriched with a `:partner_context` hash containing standing, compatibility, recent_sentiment, and interaction_pattern; sourced from Apollo Local `partner`-tagged entries with full graceful degradation when Apollo is unavailable
+
 ## [0.5.22] - 2026-03-31
 
 ### Added

data/lib/legion/llm/daemon_client.rb

@@ -105,10 +105,13 @@ module Legion
       # POSTs a conversation-level inference request to the daemon REST API.
       # Accepts a full messages array and optional tool schemas.
       # Returns a status hash with structured inference fields on success.
-      def inference(messages:, tools: [], model: nil, provider: nil, timeout: 120)
+      def inference(messages:, tools: [], model: nil, provider: nil, caller: nil, conversation_id: nil,
+                    timeout: 120)
         body = { messages: messages, tools: tools }
-        body[:model]    = model    if model
-        body[:provider] = provider if provider
+        body[:model]           = model           if model
+        body[:provider]        = provider        if provider
+        body[:caller]          = caller          if caller
+        body[:conversation_id] = conversation_id if conversation_id
 
         response = http_post('/api/llm/inference', body, timeout: timeout)
         interpret_inference_response(response)

data/lib/legion/llm/hooks/reciprocity.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module LLM
+    module Hooks
+      # Records a :given exchange event on the social graph whenever the LLM
+      # responds to a caller that carries an identity. Runs as an after_chat hook.
+      #
+      # The hook is intentionally lightweight — it does not block the response
+      # path and silently swallows all errors so a social-layer problem never
+      # surfaces to the caller.
+      module Reciprocity
+        module_function
+
+        def install
+          Legion::LLM::Hooks.after_chat do |caller: nil, **|
+            record_reciprocity(caller: caller)
+            nil
+          end
+        end
+
+        def record_reciprocity(caller:)
+          identity = caller&.dig(:requested_by, :identity)
+          return unless identity
+
+          runner = social_runner
+          return unless runner
+
+          runner.record_exchange(agent_id: identity, action: :communication, direction: :given)
+        rescue StandardError => e
+          Legion::Logging.debug "[LLM::Reciprocity] hook error: #{e.message}" if defined?(Legion::Logging)
+        end
+
+        def social_runner
+          return nil unless defined?(Legion::Extensions::Agentic::Social::Social::Client)
+
+          Legion::Extensions::Agentic::Social::Social::Client.new
+        rescue StandardError => e
+          Legion::Logging.debug "[LLM::Reciprocity] social_runner error: #{e.message}" if defined?(Legion::Logging)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/legion/llm/hooks.rb

@@ -6,6 +6,7 @@ require 'legion/llm/hooks/metering'
 require 'legion/llm/hooks/cost_tracking'
 require 'legion/llm/hooks/budget_guard'
 require 'legion/llm/hooks/reflection'
+require 'legion/llm/hooks/reciprocity'
 
 module Legion
   module LLM

data/lib/legion/llm/pipeline/steps/gaia_advisory.rb

@@ -19,6 +19,8 @@ module Legion
 
             return if advisory.nil? || advisory.empty?
 
+            enrich_advisory_with_partner_context(advisory)
+
             @enrichments['gaia:advisory'] = {
               content:   advisory_summary(advisory),
               data:      advisory,
@@ -48,6 +50,29 @@ module Legion
             @warnings << "GAIA advisory error: #{e.message}"
           end
 
+          # Exposed as a public method so specs can stub it on instances.
+          def build_partner_context(identity)
+            return default_partner_context unless apollo_local_available?
+
+            entries = ::Legion::Apollo::Local.query(
+              text:  identity,
+              tags:  ['partner'],
+              limit: 5
+            )
+
+            results = entries.is_a?(Hash) ? (entries[:results] || []) : Array(entries)
+
+            {
+              standing:            extract_standing(results),
+              compatibility:       extract_compatibility(results),
+              recent_sentiment:    extract_sentiment(results),
+              interaction_pattern: extract_interaction_pattern(results)
+            }
+          rescue StandardError => e
+            Legion::Logging.debug "[GaiaAdvisory] build_partner_context error: #{e.message}" if defined?(Legion::Logging)
+            nil
+          end
+
           private
 
           def advisory_summary(advisory)
@@ -57,6 +82,84 @@ module Legion
             parts << "suppress:#{advisory[:suppress]&.join(',')}" if advisory[:suppress]
             parts.empty? ? 'no enrichment' : parts.join(', ')
           end
+
+          def enrich_advisory_with_partner_context(advisory)
+            return unless defined?(::Legion::Gaia::BondRegistry)
+
+            identity = @request.caller&.dig(:requested_by, :identity)
+            return unless identity
+            return unless ::Legion::Gaia::BondRegistry.partner?(identity)
+
+            partner_ctx = build_partner_context(identity)
+            advisory[:partner_context] = partner_ctx if partner_ctx
+          rescue StandardError => e
+            Legion::Logging.debug "[GaiaAdvisory] partner context error: #{e.message}" if defined?(Legion::Logging)
+          end
+
+          def apollo_local_available?
+            defined?(::Legion::Apollo::Local) && ::Legion::Apollo::Local.started?
+          rescue StandardError
+            false
+          end
+
+          def default_partner_context
+            {
+              standing:            :unknown,
+              compatibility:       nil,
+              recent_sentiment:    :neutral,
+              interaction_pattern: :unknown
+            }
+          end
+
+          def extract_standing(results)
+            entry = results.find { |r| r[:content].to_s.match?(/standing/i) }
+            return :unknown unless entry
+
+            content = entry[:content].to_s
+            if content.match?(/good|trusted|positive/i)
+              :good
+            elsif content.match?(/poor|untrusted|negative/i)
+              :poor
+            else
+              :neutral
+            end
+          end
+
+          def extract_compatibility(results)
+            entry = results.find { |r| r[:content].to_s.match?(/compat/i) }
+            return nil unless entry
+
+            match = entry[:content].to_s.match(/(\d+(?:\.\d+)?)/)
+            match ? match[1].to_f : nil
+          end
+
+          def extract_sentiment(results)
+            entry = results.find { |r| r[:content].to_s.match?(/sentiment|empathy|affect/i) }
+            return :neutral unless entry
+
+            content = entry[:content].to_s
+            if content.match?(/positive|happy|pleasant/i)
+              :positive
+            elsif content.match?(/negative|unhappy|tense/i)
+              :negative
+            else
+              :neutral
+            end
+          end
+
+          def extract_interaction_pattern(results)
+            entry = results.find { |r| r[:content].to_s.match?(/interaction|memory|trace/i) }
+            return :unknown unless entry
+
+            content = entry[:content].to_s
+            if content.match?(/frequent|regular|daily/i)
+              :frequent
+            elsif content.match?(/occasional|sometimes/i)
+              :occasional
+            else
+              :infrequent
+            end
+          end
         end
       end
     end

data/lib/legion/llm/routes.rb

@@ -289,10 +289,12 @@ module Legion
           body = parse_request_body
           validate_required!(body, :messages)
 
-          messages = body[:messages]
-          raw_tools = body[:tools]
-          model    = body[:model]
-          provider = body[:provider]
+          messages        = body[:messages]
+          raw_tools       = body[:tools]
+          model           = body[:model]
+          provider        = body[:provider]
+          caller_context  = body[:caller]
+          conversation_id = body[:conversation_id]
 
           unless messages.is_a?(Array)
             halt 400, { 'Content-Type' => 'application/json' },
@@ -331,13 +333,17 @@ module Legion
             { role: ms[:role].to_s, content: ms[:content].to_s }
           end
 
-          result = Legion::LLM.chat(
+          effective_caller = caller_context || { source: 'api', path: request.path }
+          chat_opts = {
             messages: normalized_messages,
             model:    model,
             provider: provider,
             tools:    tool_declarations,
-            caller:   { source: 'api', path: request.path }
-          )
+            caller:   effective_caller
+          }
+          chat_opts[:conversation_id] = conversation_id if conversation_id
+
+          result = Legion::LLM.chat(**chat_opts)
 
           if result.is_a?(Legion::LLM::Pipeline::Response)
             raw_msg   = result.message

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.5.22'
+    VERSION = '0.5.24'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.5.22
+  version: 0.5.24
 platform: ruby
 authors:
 - Esity
@@ -253,6 +253,7 @@ files:
 - lib/legion/llm/hooks/cost_tracking.rb
 - lib/legion/llm/hooks/metering.rb
 - lib/legion/llm/hooks/rag_guard.rb
+- lib/legion/llm/hooks/reciprocity.rb
 - lib/legion/llm/hooks/reflection.rb
 - lib/legion/llm/hooks/response_guard.rb
 - lib/legion/llm/off_peak.rb