legion-llm 0.5.21 → 0.5.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08ccdbe9c1f4187acdcae49df633370d7fecb9866fa441aa1e95a3f932d5c9e6'
-  data.tar.gz: df48f1ba0ef83a0fb26ba67865bf0f69ee415a349f2fc0e4ec40dd70f7f70815
+  metadata.gz: 9bfeb8ca0bacd82ef217f76275e20d8df7a15f83a324bcf9f090232ed7374837
+  data.tar.gz: cb4ceb07ae6004670a9e582a1fad6d3d2bc9a87e5a123116ff1ef995e5576744
 SHA512:
-  metadata.gz: 9237a7a67d3b843bef628817cbd679fdce2f690e35b35f817e38b39c2e46918cb87d1c81b0b3c5a48589f54a163cbd7f3ef5956e73ba3c96f4f0ee3c1f803c9d
-  data.tar.gz: 996f35c9bb47ff5046bfd10fe48440a783480b81956b6e0b7f1f10bd860fd4aaab9dd9fcda3378761ac2942ea7f9c886d0bd19722cee9b46936f7ae8c662aa9d
+  metadata.gz: 0a24a288be1a94ef846aea5c47871c7f7875e99749078a77a431af854fbdbf3582cfdf1191aa570d9ae08d77f723bb653fa4b431258c77f5e050e2bd8ec367ef
+  data.tar.gz: '0508aced0a6e1e8f09fb2e6ae2c8121f81d2b8efe765e37b1bb7d23c5ae688dcb9dc314c0a92cb6caef004c0ee8767f3b79e961728d3f278a5ceaf99bd16d844'

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## [Unreleased]
 
+## [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
+- Auto-chunking for oversized Ollama embedding inputs via `lex-knowledge` Chunker with character-split fallback
+- `average_vectors` for document-level embedding from multiple chunks
+- Per-model Ollama context limits (`OLLAMA_CONTEXT_CHARS`): mxbai-embed-large 2048, nomic-embed-text 32768
+- `lex-knowledge` added as a dependency for semantic chunking
+
+### Fixed
+- `handle_embed_failure` no longer permanently mutates `@embedding_provider` — failover is per-request only
+- `ollama_preferred` order corrected: `mxbai-embed-large` (1024 dims) first, `nomic-embed-text` (768 dims) second
+
 ## [0.5.21] - 2026-03-31
 
 ### Added

data/legion-llm.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'lex-bedrock'
   spec.add_dependency 'lex-claude'
   spec.add_dependency 'lex-gemini'
+  spec.add_dependency 'lex-knowledge'
   spec.add_dependency 'lex-openai'
   spec.add_dependency 'ruby_llm', '~> 1.13'
   spec.add_dependency 'tzinfo', '>= 2.0'

data/lib/legion/llm/embeddings.rb

@@ -16,6 +16,14 @@ module Legion
 
       TARGET_DIMENSION = 1024
 
+      OLLAMA_CONTEXT_CHARS = {
+        'mxbai-embed-large'      => 2048,
+        'bge-large'              => 2048,
+        'snowflake-arctic-embed' => 2048,
+        'nomic-embed-text'       => 32_768
+      }.freeze
+      OLLAMA_DEFAULT_CONTEXT_CHARS = 2048
+
       class << self
         def generate(text:, model: nil, provider: nil, dimensions: nil)
           return { vector: nil, model: model, provider: provider, error: 'LLM not started' } unless LLM.started?
@@ -97,8 +105,6 @@ module Legion
           fallback = find_fallback_provider(failed_provider)
           if fallback
             Legion::Logging.info "Embedding failover: #{failed_provider} -> #{fallback[:provider]}" if defined?(Legion::Logging)
-            LLM.instance_variable_set(:@embedding_provider, fallback[:provider])
-            LLM.instance_variable_set(:@embedding_model, fallback[:model])
             generate(text: text, model: fallback[:model], provider: fallback[:provider])
           else
             { vector: nil, model: failed_model, provider: failed_provider, error: error.message }
@@ -177,6 +183,9 @@ module Legion
         end
 
         def generate_ollama(text:, model:)
+          max_chars = ollama_context_chars(model)
+          return generate_ollama_chunked(text: text, model: model, max_chars: max_chars) if text.length > max_chars
+
           result = ollama_embed_request(model: model, input: text)
           vector = result['embeddings']&.first
           vector = apply_dimension_enforcement(vector, :ollama) if vector
@@ -185,14 +194,63 @@ module Legion
           { vector: vector, model: model, provider: :ollama, dimensions: vector&.size || 0, tokens: 0 }
         end
 
+        def generate_ollama_chunked(text:, model:, max_chars:)
+          chunks = chunk_text(text, max_chars: max_chars)
+          vectors = chunks.filter_map do |chunk|
+            result = ollama_embed_request(model: model, input: chunk[:content])
+            result['embeddings']&.first
+          end
+
+          return { vector: nil, model: model, provider: :ollama, error: 'all chunks failed embedding' } if vectors.empty?
+
+          avg = average_vectors(vectors)
+          avg = apply_dimension_enforcement(avg, :ollama)
+          return dimension_error(model, :ollama, avg) if avg.is_a?(String)
+
+          { vector: avg, model: model, provider: :ollama, dimensions: avg.size, tokens: 0, chunks: vectors.size }
+        end
+
         def generate_ollama_batch(texts:, model:)
-          result = ollama_embed_request(model: model, input: texts)
-          vectors = result['embeddings'] || []
-          vectors.each_with_index.map do |vec, i|
-            build_batch_entry(vec, model, :ollama, i)
+          max_chars = ollama_context_chars(model)
+          texts.each_with_index.map do |text, i|
+            if text.length > max_chars
+              result = generate_ollama_chunked(text: text, model: model, max_chars: max_chars)
+              build_batch_entry(result[:vector], model, :ollama, i)
+            else
+              result = ollama_embed_request(model: model, input: text)
+              vec = result['embeddings']&.first
+              build_batch_entry(vec, model, :ollama, i)
+            end
           end
         end
 
+        def chunk_text(text, max_chars:)
+          if defined?(Legion::Extensions::Knowledge::Helpers::Chunker)
+            chunker = Legion::Extensions::Knowledge::Helpers::Chunker
+            max_tokens = max_chars / chunker::CHARS_PER_TOKEN
+            sections = [{ content: text, heading: nil, section_path: nil, source_file: nil }]
+            chunker.chunk(sections: sections, max_tokens: max_tokens)
+          else
+            text.chars.each_slice(max_chars).map { |s| { content: s.join } }
+          end
+        rescue StandardError
+          text.chars.each_slice(max_chars).map { |s| { content: s.join } }
+        end
+
+        def average_vectors(vectors)
+          return vectors.first if vectors.size == 1
+
+          dim = vectors.first.size
+          sum = Array.new(dim, 0.0)
+          vectors.each { |v| v.each_with_index { |val, i| sum[i] += val } }
+          sum.map { |s| s / vectors.size }
+        end
+
+        def ollama_context_chars(model)
+          base = model.to_s.split(':').first
+          OLLAMA_CONTEXT_CHARS[base] || OLLAMA_DEFAULT_CONTEXT_CHARS
+        end
+
         def ollama_embed_request(model:, input:)
           base_url = Legion::Settings.dig(:llm, :providers, :ollama, :base_url) || 'http://localhost:11434'
           conn = Faraday.new(url: base_url) do |f|

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

@@ -150,7 +150,7 @@ module Legion
             bedrock: 'amazon.titan-embed-text-v2:0',
             openai:  'text-embedding-3-small'
           },
-          ollama_preferred:  %w[nomic-embed-text mxbai-embed-large bge-large snowflake-arctic-embed]
+          ollama_preferred:  %w[mxbai-embed-large nomic-embed-text bge-large snowflake-arctic-embed]
         }
       end
 

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.5.21'
+    VERSION = '0.5.23'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.5.21
+  version: 0.5.23
 platform: ruby
 authors:
 - Esity
@@ -121,6 +121,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: lex-knowledge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: lex-openai
   requirement: !ruby/object:Gem::Requirement
@@ -239,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