lex-agentic-language 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2388849ad378d8489580d4638dc181111798e6ce0a153e99fe40f2c441152b96
-  data.tar.gz: 05c2295ad8bf6a17e2592cce376b6c15408c4bf5f0a35786cdfe650ecd50ffa1
+  metadata.gz: 79cfb7e1534a2010a54b836636c9a5406fefda03bb97cb700f131f1a92a6e77c
+  data.tar.gz: 026cd8c1a5831eed7555d231471595bb2d3ab5ba832d3a98c90646c01baa54f4
 SHA512:
-  metadata.gz: 4b68a01ec6173f4ad3bcb486ed33c9ffe87c269da569c6615e49d96366f79a6f997a1265827f511343a735f15cfdc3464f032a0a9db825556b6b38d2519af96d
-  data.tar.gz: 9baccb232491d12120647c84aa5aaae42a2936f2aec7f83b681fab2226af871f13433277c964fc612afbef07c17275e4c2a5231168f2f158545658d07469e5b1
+  metadata.gz: 347a89a7300d788e8b76b1882c52ab280ad99c8ed1c38981cc7de53071dbf905678b086847d9923b7fa9242a08189e78adc658a7f553aace3b0669712d466119
+  data.tar.gz: 3b15a51fe618f5f478c48182688803a626558eca1d20a66093b5cdf384e3dbc53e41a96f61a3c4360711273cda056154cc997ac62b84a6a3de5e986519a9a0b4

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.1.11] - 2026-05-07
+### Fixed
+- Narrator LLM enhancement now sends native chat message payloads with system/user roles while preserving legacy session fallback for older test doubles.
+- LLM narration state maps reflection `unacted_count` into pending adaptations.
+
+## [0.1.10] - 2026-04-27
+### Fixed
+- Narrator LLM enhancement now skips empty idle narration and rate-limits provider failure warnings without warning-level backtrace floods. Fixes #7
+
 ## [0.1.9] - 2026-04-22
 ### Added
 - InnerSpeech::Actor::DecayInnerSpeech (60s) — first actor in the extension, enables autonomous salience decay

data/lib/legion/extensions/agentic/language/narrator/helpers/llm_enhancer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'concurrent/atomic/atomic_reference'
+
 module Legion
   module Extensions
     module Agentic
@@ -13,6 +15,8 @@ module Legion
                 Write 3-5 sentences that feel like genuine introspection, not a report.
                 Vary your sentence structure. Use present tense. Be concise and vivid.
               PROMPT
+              FAILURE_LOG_INTERVAL = 60
+              FAILURE_LOGGED_AT = Concurrent::AtomicReference.new
 
               module_function
 
@@ -33,8 +37,7 @@ module Legion
                 response = llm_ask(prompt)
                 parse_narrate_response(response)
               rescue StandardError => e
-                log.warn("[narrator:llm] narrate failed: #{e.message}")
-                log.warn(e.backtrace)
+                log_failure(e)
                 nil
               end
 
@@ -48,16 +51,39 @@ module Legion
                     caller:  { extension: 'lex-agentic-language', mode: :narrator }
                   )
                   content = response&.message&.dig(:content)
-                  ::Struct.new(:content).new(content) if content
                 else
-                  chat = Legion::LLM.chat # rubocop:disable Legion/HelperMigration/DirectLlm
-                  chat.with_instructions(SYSTEM_PROMPT)
-                  chat.ask(prompt)
+                  response = Legion::LLM.chat( # rubocop:disable Legion/HelperMigration/DirectLlm
+                    message: [
+                      { role: 'system', content: SYSTEM_PROMPT },
+                      { role: 'user', content: prompt }
+                    ],
+                    caller:  { extension: 'lex-agentic-language', mode: :narrator }
+                  )
+                  content = extract_response_content(response, prompt)
                 end
+                ::Struct.new(:content).new(content) if content
               end
 
               private_class_method :llm_ask
 
+              def extract_response_content(response, prompt = nil)
+                return response.strip if response.is_a?(String)
+                return response.content if response.respond_to?(:content)
+
+                if response.respond_to?(:ask)
+                  response.with_instructions(SYSTEM_PROMPT) if response.respond_to?(:with_instructions)
+                  asked = response.ask(prompt)
+                  return extract_response_content(asked)
+                end
+                return nil unless response.is_a?(Hash)
+
+                response[:content] || response['content'] ||
+                  response.dig(:message, :content) || response.dig('message', 'content') ||
+                  response[:response] || response['response']
+              end
+
+              private_class_method :extract_response_content
+
               def pipeline_available?
                 !!(defined?(Legion::LLM::Pipeline::GaiaCaller) &&
                   Legion::LLM.respond_to?(:pipeline_enabled?) &&
@@ -69,6 +95,25 @@ module Legion
 
               private_class_method :pipeline_available?
 
+              def log_failure(error)
+                if log_failure_now?
+                  log.warn("[narrator:llm] narrate failed: #{error.class}: #{error.message}")
+                  FAILURE_LOGGED_AT.set(Time.now.utc)
+                end
+                log.debug(error.backtrace)
+              end
+
+              private_class_method :log_failure
+
+              def log_failure_now?
+                last_logged_at = FAILURE_LOGGED_AT.get
+                return true unless last_logged_at
+
+                (Time.now.utc - last_logged_at) >= FAILURE_LOG_INTERVAL
+              end
+
+              private_class_method :log_failure_now?
+
               def build_narrate_prompt(sections_data)
                 parts = [
                   'Generate a first-person internal monologue based on the following cognitive state:',

data/lib/legion/extensions/agentic/language/narrator/runners/narrator.rb

@@ -13,7 +13,7 @@ module Legion
               def narrate(tick_results: {}, cognitive_state: {}, **)
                 entry = Helpers::Synthesizer.narrate(tick_results: tick_results, cognitive_state: cognitive_state)
 
-                if Helpers::LlmEnhancer.available?
+                if Helpers::LlmEnhancer.available? && meaningful_for_llm?(tick_results, cognitive_state)
                   sections_data = build_llm_sections_data(tick_results, cognitive_state, entry)
                   llm_result = Helpers::LlmEnhancer.narrate(sections_data: sections_data)
                   if llm_result
@@ -103,6 +103,25 @@ module Legion
                 @journal ||= Helpers::Journal.new
               end
 
+              def meaningful_for_llm?(tick_results, cognitive_state)
+                meaningful_hash?(tick_results) || meaningful_hash?(cognitive_state)
+              end
+
+              def meaningful_hash?(value)
+                return false unless value.is_a?(Hash)
+
+                value.any? do |_, nested|
+                  case nested
+                  when Hash
+                    meaningful_hash?(nested)
+                  when Array
+                    nested.any?
+                  else
+                    !nested.nil?
+                  end
+                end
+              end
+
               def build_llm_sections_data(tick_results, cognitive_state, entry)
                 {
                   emotion:    llm_emotion_data(tick_results, cognitive_state),
@@ -168,7 +187,7 @@ module Legion
                 r = cognitive_state[:reflection] || {}
                 {
                   health:              r[:health] || 1.0,
-                  pending_adaptations: r[:pending_adaptations] || 0
+                  pending_adaptations: r[:pending_adaptations] || r[:unacted_count] || 0
                 }
               end
 

data/lib/legion/extensions/agentic/language/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Language
-        VERSION = '0.1.9'
+        VERSION = '0.1.11'
       end
     end
   end

data/spec/legion/extensions/agentic/language/narrator/helpers/llm_enhancer_spec.rb

@@ -49,27 +49,32 @@ RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Helpers::LlmEnha
 
     context 'when LLM returns a response' do
       it 'returns the response content as a string' do
-        response_double = double('response', content: 'I feel alert and curious about what lies ahead.')
-        chat_double = double('chat')
-        allow(chat_double).to receive(:with_instructions)
-        allow(chat_double).to receive(:ask).and_return(response_double)
         llm_double = double('Legion::LLM', started?: true)
-        allow(llm_double).to receive(:chat).and_return(chat_double)
+        allow(llm_double).to receive(:chat).and_return(content: 'I feel alert and curious about what lies ahead.')
         stub_const('Legion::LLM', llm_double)
 
         result = described_class.narrate(sections_data: sections_data)
         expect(result).to be_a(String)
         expect(result).to eq('I feel alert and curious about what lies ahead.')
       end
+
+      it 'sends system instructions and user prompt in the native chat message payload' do
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_return(content: 'native narrative')
+        stub_const('Legion::LLM', llm_double)
+
+        described_class.narrate(sections_data: sections_data)
+
+        expect(llm_double).to have_received(:chat)
+          .with(hash_including(message: array_including(hash_including(role: 'system'),
+                                                        hash_including(role: 'user'))))
+      end
     end
 
     context 'when LLM returns nil response' do
       it 'returns nil' do
-        chat_double = double('chat')
-        allow(chat_double).to receive(:with_instructions)
-        allow(chat_double).to receive(:ask).and_return(nil)
         llm_double = double('Legion::LLM', started?: true)
-        allow(llm_double).to receive(:chat).and_return(chat_double)
+        allow(llm_double).to receive(:chat).and_return(nil)
         stub_const('Legion::LLM', llm_double)
 
         result = described_class.narrate(sections_data: sections_data)
@@ -78,26 +83,34 @@ RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Helpers::LlmEnha
     end
 
     context 'when an error occurs' do
-      it 'returns nil and logs a warning' do
+      before { described_class::FAILURE_LOGGED_AT.set(nil) }
+
+      it 'returns nil and logs a concise warning with debug backtrace' do
         llm_double = double('Legion::LLM', started?: true)
         allow(llm_double).to receive(:chat).and_raise(StandardError, 'connection failed')
         stub_const('Legion::LLM', llm_double)
 
-        expect(Legion::Logging).to receive(:warn).with(/narrator:llm.*narrate failed/)
-        expect(Legion::Logging).to receive(:warn).with(instance_of(Array))
+        expect(Legion::Logging).to receive(:warn).with(/narrator:llm.*StandardError: connection failed/)
+        expect(Legion::Logging).to receive(:debug).with(instance_of(Array))
         result = described_class.narrate(sections_data: sections_data)
         expect(result).to be_nil
       end
+
+      it 'throttles repeated failure warnings' do
+        llm_double = double('Legion::LLM', started?: true)
+        allow(llm_double).to receive(:chat).and_raise(StandardError, 'connection failed')
+        stub_const('Legion::LLM', llm_double)
+        allow(Legion::Logging).to receive(:debug)
+
+        expect(Legion::Logging).to receive(:warn).once
+        2.times { described_class.narrate(sections_data: sections_data) }
+      end
     end
 
     context 'with empty sections_data' do
       it 'does not raise and returns a string when LLM responds' do
-        response_double = double('response', content: 'Everything seems quiet.')
-        chat_double = double('chat')
-        allow(chat_double).to receive(:with_instructions)
-        allow(chat_double).to receive(:ask).and_return(response_double)
         llm_double = double('Legion::LLM', started?: true)
-        allow(llm_double).to receive(:chat).and_return(chat_double)
+        allow(llm_double).to receive(:chat).and_return(content: 'Everything seems quiet.')
         stub_const('Legion::LLM', llm_double)
 
         result = described_class.narrate(sections_data: {})

data/spec/legion/extensions/agentic/language/narrator/runners/narrator_llm_spec.rb

@@ -4,9 +4,10 @@ RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Runners::Narrato
   let(:client) { Legion::Extensions::Agentic::Language::Narrator::Client.new }
 
   describe '#narrate with LLM available' do
+    let(:chat_double) { double('chat') }
+
     before do
       response_double = double('response', content: 'I feel a deep sense of focus and possibility.')
-      chat_double = double('chat')
       allow(chat_double).to receive(:with_instructions)
       allow(chat_double).to receive(:ask).and_return(response_double)
       llm_double = double('Legion::LLM', started?: true)
@@ -22,8 +23,8 @@ RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Runners::Narrato
       expect(result[:source]).to eq(:llm)
     end
 
-    it 'returns the LLM narrative string' do
-      result = client.narrate(tick_results: {}, cognitive_state: {})
+    it 'returns the LLM narrative string when there is meaningful cognitive data' do
+      result = client.narrate(tick_results: { emotional_evaluation: { valence: 0.6 } }, cognitive_state: {})
       expect(result[:narrative]).to eq('I feel a deep sense of focus and possibility.')
     end
 
@@ -34,9 +35,18 @@ RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Runners::Narrato
     end
 
     it 'appends to journal' do
-      client.narrate(tick_results: {}, cognitive_state: {})
+      client.narrate(tick_results: { emotional_evaluation: { valence: 0.6 } }, cognitive_state: {})
       expect(client.journal.size).to eq(1)
     end
+
+    it 'uses the mechanical pipeline for empty idle narration' do
+      expect(chat_double).not_to receive(:ask)
+
+      result = client.narrate(tick_results: {}, cognitive_state: {})
+
+      expect(result).not_to have_key(:source)
+      expect(result[:narrative]).to be_a(String)
+    end
   end
 
   describe '#narrate with LLM available but narrate returns nil' do
@@ -50,7 +60,7 @@ RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Runners::Narrato
     end
 
     it 'falls back to mechanical pipeline' do
-      result = client.narrate(tick_results: {}, cognitive_state: {})
+      result = client.narrate(tick_results: { emotional_evaluation: { valence: 0.6 } }, cognitive_state: {})
       expect(result).not_to have_key(:source)
       expect(result[:narrative]).to be_a(String)
     end

data/spec/legion/extensions/agentic/language/narrator/runners/narrator_spec.rb

@@ -33,6 +33,15 @@ RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Runners::Narrato
     end
   end
 
+  describe 'reflection data for LLM narration' do
+    it 'maps reflection unacted_count to pending_adaptations' do
+      data = client.send(:llm_reflection_data, reflection: { health: 0.7, unacted_count: 3 })
+
+      expect(data[:health]).to eq(0.7)
+      expect(data[:pending_adaptations]).to eq(3)
+    end
+  end
+
   describe '#recent_entries' do
     before do
       5.times { |i| client.narrate(tick_results: { emotional_evaluation: { valence: i * 0.2 } }, cognitive_state: {}) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-language
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Esity