lex-agentic-language 0.1.0

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Helpers::Journal do
+  subject(:journal) { described_class.new }
+
+  let(:entry) do
+    { timestamp: Time.now.utc, narrative: 'I am alert.', mood: :energized, sections: {} }
+  end
+
+  describe '#append' do
+    it 'adds an entry' do
+      journal.append(entry)
+      expect(journal.size).to eq(1)
+    end
+
+    it 'returns the appended entry' do
+      result = journal.append(entry)
+      expect(result[:narrative]).to eq('I am alert.')
+    end
+
+    it 'trims to MAX_JOURNAL_SIZE' do
+      max = Legion::Extensions::Agentic::Language::Narrator::Helpers::Constants::MAX_JOURNAL_SIZE
+      (max + 10).times { |i| journal.append(entry.merge(narrative: "Entry #{i}")) }
+      expect(journal.size).to eq(max)
+    end
+  end
+
+  describe '#recent' do
+    it 'returns last N entries' do
+      5.times { |i| journal.append(entry.merge(narrative: "Entry #{i}")) }
+      result = journal.recent(limit: 3)
+      expect(result.size).to eq(3)
+      expect(result.last[:narrative]).to eq('Entry 4')
+    end
+
+    it 'returns all entries when fewer than limit' do
+      2.times { |i| journal.append(entry.merge(narrative: "Entry #{i}")) }
+      expect(journal.recent(limit: 10).size).to eq(2)
+    end
+  end
+
+  describe '#since' do
+    it 'returns entries after a timestamp' do
+      old = entry.merge(timestamp: Time.now.utc - 3600)
+      recent_entry = entry.merge(timestamp: Time.now.utc)
+
+      journal.append(old)
+      journal.append(recent_entry)
+
+      cutoff = Time.now.utc - 1800
+      result = journal.since(cutoff)
+      expect(result.size).to eq(1)
+    end
+  end
+
+  describe '#by_mood' do
+    it 'filters entries by mood' do
+      journal.append(entry.merge(mood: :energized))
+      journal.append(entry.merge(mood: :dormant))
+      journal.append(entry.merge(mood: :energized))
+
+      result = journal.by_mood(:energized)
+      expect(result.size).to eq(2)
+    end
+  end
+
+  describe '#stats' do
+    it 'returns empty stats for empty journal' do
+      stats = journal.stats
+      expect(stats[:total]).to eq(0)
+      expect(stats[:moods]).to eq({})
+    end
+
+    it 'returns mood distribution and timestamps' do
+      journal.append(entry.merge(mood: :energized))
+      journal.append(entry.merge(mood: :neutral))
+      journal.append(entry.merge(mood: :energized))
+
+      stats = journal.stats
+      expect(stats[:total]).to eq(3)
+      expect(stats[:moods][:energized]).to eq(2)
+      expect(stats[:moods][:neutral]).to eq(1)
+      expect(stats).to have_key(:oldest)
+      expect(stats).to have_key(:newest)
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all entries' do
+      3.times { journal.append(entry) }
+      journal.clear
+      expect(journal.size).to eq(0)
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Helpers::LlmEnhancer do
+  describe '.available?' do
+    context 'when Legion::LLM is not defined' do
+      it 'returns false' do
+        hide_const('Legion::LLM')
+        expect(described_class.available?).to be false
+      end
+    end
+
+    context 'when Legion::LLM is defined but not started' do
+      it 'returns false' do
+        llm_double = double('Legion::LLM', started?: false)
+        stub_const('Legion::LLM', llm_double)
+        expect(described_class.available?).to be false
+      end
+    end
+
+    context 'when Legion::LLM is started' do
+      it 'returns true' do
+        llm_double = double('Legion::LLM', started?: true)
+        stub_const('Legion::LLM', llm_double)
+        expect(described_class.available?).to be true
+      end
+    end
+
+    context 'when Legion::LLM raises an error' do
+      it 'returns false' do
+        llm_double = double('Legion::LLM')
+        allow(llm_double).to receive(:respond_to?).and_raise(StandardError)
+        stub_const('Legion::LLM', llm_double)
+        expect(described_class.available?).to be false
+      end
+    end
+  end
+
+  describe '.narrate' do
+    let(:sections_data) do
+      {
+        emotion:    { valence: 0.6, arousal: 0.7, gut: nil },
+        curiosity:  { intensity: 0.5, wonder_count: 3, top_wonder: 'What is next?' },
+        prediction: { confidence: 0.8, pending: 2, mode: :causal },
+        memory:     { trace_count: 42, health: 0.9 },
+        attention:  { spotlight: 4, peripheral: 2, focused_domains: ['planning'] },
+        reflection: { health: 0.95, pending_adaptations: 1 }
+      }
+    end
+
+    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)
+        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
+    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)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.narrate(sections_data: sections_data)
+        expect(result).to be_nil
+      end
+    end
+
+    context 'when an error occurs' do
+      it 'returns nil and logs a warning' 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/)
+        result = described_class.narrate(sections_data: sections_data)
+        expect(result).to be_nil
+      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)
+        stub_const('Legion::LLM', llm_double)
+
+        result = described_class.narrate(sections_data: {})
+        expect(result).to eq('Everything seems quiet.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Helpers::Prose do
+  let(:prose) { described_class }
+
+  describe '.emotion_phrase' do
+    it 'describes high positive valence with high arousal' do
+      result = prose.emotion_phrase(valence: 0.8, arousal: 0.9)
+      expect(result).to include('highly alert')
+      expect(result).to include('engaged and optimistic')
+    end
+
+    it 'describes low negative valence' do
+      result = prose.emotion_phrase(valence: -0.4, arousal: 0.3)
+      expect(result).to include('slightly uneasy')
+    end
+
+    it 'includes gut signal when strong positive' do
+      result = prose.emotion_phrase(valence: 0.0, arousal: 0.5, gut: { signal: 0.5 })
+      expect(result).to include('something important')
+    end
+
+    it 'includes gut signal when strong negative' do
+      result = prose.emotion_phrase(valence: 0.0, arousal: 0.5, gut: { signal: -0.5 })
+      expect(result).to include('uneasy feeling')
+    end
+
+    it 'omits gut note when signal is mild' do
+      result = prose.emotion_phrase(valence: 0.0, arousal: 0.5, gut: { signal: 0.1 })
+      expect(result).not_to include('gut')
+      expect(result).not_to include('important')
+    end
+  end
+
+  describe '.curiosity_phrase' do
+    it 'describes high curiosity with wonders' do
+      result = prose.curiosity_phrase(intensity: 0.8, top_wonder: 'Why are traces sparse?', wonder_count: 3)
+      expect(result).to include('deeply curious')
+      expect(result).to include('3 open questions')
+      expect(result).to include('Why are traces sparse?')
+    end
+
+    it 'describes no curiosity' do
+      result = prose.curiosity_phrase(intensity: 0.0)
+      expect(result).to include('not particularly curious')
+    end
+
+    it 'handles single wonder' do
+      result = prose.curiosity_phrase(intensity: 0.5, top_wonder: 'What is this?', wonder_count: 1)
+      expect(result).to include('1 open question')
+    end
+  end
+
+  describe '.prediction_phrase' do
+    it 'describes high confidence' do
+      result = prose.prediction_phrase(confidence: 0.9, pending: 2, mode: :functional_mapping)
+      expect(result).to include('confident')
+      expect(result).to include('functional_mapping')
+      expect(result).to include('2 pending predictions')
+    end
+
+    it 'describes low confidence' do
+      result = prose.prediction_phrase(confidence: 0.2)
+      expect(result).to include('uncertain')
+    end
+  end
+
+  describe '.attention_phrase' do
+    it 'describes spotlight and peripheral counts' do
+      result = prose.attention_phrase(spotlight: 3, peripheral: 5)
+      expect(result).to include('3 signals in spotlight')
+      expect(result).to include('5 in peripheral')
+    end
+
+    it 'includes manual focus domains' do
+      result = prose.attention_phrase(spotlight: 1, peripheral: 0, focused_domains: %w[terraform vault])
+      expect(result).to include('terraform')
+      expect(result).to include('vault')
+    end
+  end
+
+  describe '.memory_phrase' do
+    it 'describes memory state' do
+      result = prose.memory_phrase(trace_count: 150, health: 0.85)
+      expect(result).to include('150 active traces')
+      expect(result).to include('functioning well')
+    end
+  end
+
+  describe '.reflection_phrase' do
+    it 'describes healthy state' do
+      result = prose.reflection_phrase(health: 0.95)
+      expect(result).to include('operating at full capacity')
+    end
+
+    it 'includes pending adaptations' do
+      result = prose.reflection_phrase(health: 0.6, pending_adaptations: 3, recent_severity: :significant)
+      expect(result).to include('3 pending adaptation')
+      expect(result).to include('significant')
+    end
+  end
+
+  describe '.overall_narrative' do
+    it 'joins sections with periods' do
+      result = prose.overall_narrative(['I am alert', 'I am curious', 'Memory is good'])
+      expect(result).to eq('I am alert. I am curious. Memory is good.')
+    end
+
+    it 'skips empty sections' do
+      result = prose.overall_narrative(['I am alert', '', nil, 'Memory is good'])
+      expect(result).to eq('I am alert. Memory is good.')
+    end
+  end
+
+  describe '.emotion_label_for' do
+    it 'returns correct labels for valence ranges' do
+      expect(prose.emotion_label_for(0.8)).to eq('engaged and optimistic')
+      expect(prose.emotion_label_for(0.3)).to eq('calm and steady')
+      expect(prose.emotion_label_for(0.0)).to eq('emotionally neutral')
+      expect(prose.emotion_label_for(-0.3)).to eq('slightly uneasy')
+      expect(prose.emotion_label_for(-0.8)).to eq('distressed')
+    end
+  end
+
+  describe '.health_label_for' do
+    it 'returns correct labels for health ranges' do
+      expect(prose.health_label_for(0.95)).to eq('operating at full capacity')
+      expect(prose.health_label_for(0.8)).to eq('functioning well overall')
+      expect(prose.health_label_for(0.6)).to eq('showing some strain')
+      expect(prose.health_label_for(0.4)).to eq('experiencing significant cognitive difficulty')
+      expect(prose.health_label_for(0.2)).to eq('in cognitive distress')
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Helpers::Synthesizer do
+  let(:synth) { described_class }
+
+  describe '.narrate' do
+    it 'produces a narrative entry with all sections' do
+      result = synth.narrate(
+        tick_results:    {
+          emotional_evaluation: { valence: 0.5, arousal: 0.8 },
+          sensory_processing:   { spotlight: 2, peripheral: 4 }
+        },
+        cognitive_state: {
+          curiosity: { intensity: 0.6, active_count: 3, top_question: 'Why?' }
+        }
+      )
+
+      expect(result[:narrative]).to be_a(String)
+      expect(result[:narrative].length).to be > 10
+      expect(result[:mood]).to be_a(Symbol)
+      expect(result[:timestamp]).to be_a(Time)
+      expect(result[:sections]).to have_key(:attention)
+      expect(result[:sections]).to have_key(:emotion)
+      expect(result[:sections]).to have_key(:curiosity)
+      expect(result[:sections]).to have_key(:prediction)
+      expect(result[:sections]).to have_key(:memory)
+      expect(result[:sections]).to have_key(:reflection)
+    end
+
+    it 'handles empty inputs gracefully' do
+      result = synth.narrate(tick_results: {}, cognitive_state: {})
+      expect(result[:narrative]).to be_a(String)
+      expect(result[:mood]).to eq(:neutral)
+    end
+  end
+
+  describe '.infer_mood' do
+    it 'returns :energized for positive valence + high arousal' do
+      expect(synth.infer_mood({ emotional_evaluation: { valence: 0.5, arousal: 0.7 } }, {})).to eq(:energized)
+    end
+
+    it 'returns :content for positive valence + low arousal' do
+      expect(synth.infer_mood({ emotional_evaluation: { valence: 0.5, arousal: 0.3 } }, {})).to eq(:content)
+    end
+
+    it 'returns :anxious for negative valence + high arousal' do
+      expect(synth.infer_mood({ emotional_evaluation: { valence: -0.5, arousal: 0.7 } }, {})).to eq(:anxious)
+    end
+
+    it 'returns :subdued for negative valence + low arousal' do
+      expect(synth.infer_mood({ emotional_evaluation: { valence: -0.5, arousal: 0.3 } }, {})).to eq(:subdued)
+    end
+
+    it 'returns :alert for neutral valence + very high arousal' do
+      expect(synth.infer_mood({ emotional_evaluation: { valence: 0.0, arousal: 0.9 } }, {})).to eq(:alert)
+    end
+
+    it 'returns :dormant for neutral valence + very low arousal' do
+      expect(synth.infer_mood({ emotional_evaluation: { valence: 0.0, arousal: 0.1 } }, {})).to eq(:dormant)
+    end
+
+    it 'returns :neutral for moderate values' do
+      expect(synth.infer_mood({ emotional_evaluation: { valence: 0.0, arousal: 0.5 } }, {})).to eq(:neutral)
+    end
+  end
+
+  describe '.classify_mood' do
+    it 'classifies all seven moods' do
+      expect(synth.classify_mood(0.5, 0.8)).to eq(:energized)
+      expect(synth.classify_mood(0.5, 0.3)).to eq(:content)
+      expect(synth.classify_mood(-0.5, 0.8)).to eq(:anxious)
+      expect(synth.classify_mood(-0.5, 0.3)).to eq(:subdued)
+      expect(synth.classify_mood(0.0, 0.9)).to eq(:alert)
+      expect(synth.classify_mood(0.0, 0.1)).to eq(:dormant)
+      expect(synth.classify_mood(0.0, 0.5)).to eq(:neutral)
+    end
+  end
+
+  describe '.extract_focused_domains' do
+    it 'extracts domain names from manual_focus hash' do
+      focus = { manual_focus: { terraform: {}, vault: {} } }
+      expect(synth.extract_focused_domains(focus)).to eq(%w[terraform vault])
+    end
+
+    it 'returns empty array for nil' do
+      expect(synth.extract_focused_domains({})).to eq([])
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Runners::Narrator, 'LLM integration' do
+  let(:client) { Legion::Extensions::Agentic::Language::Narrator::Client.new }
+
+  describe '#narrate with LLM available' do
+    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)
+      allow(llm_double).to receive(:chat).and_return(chat_double)
+      stub_const('Legion::LLM', llm_double)
+    end
+
+    it 'returns source: :llm when LLM narrate succeeds' do
+      result = client.narrate(
+        tick_results:    { emotional_evaluation: { valence: 0.6, arousal: 0.7 } },
+        cognitive_state: {}
+      )
+      expect(result[:source]).to eq(:llm)
+    end
+
+    it 'returns the LLM narrative string' do
+      result = client.narrate(tick_results: {}, cognitive_state: {})
+      expect(result[:narrative]).to eq('I feel a deep sense of focus and possibility.')
+    end
+
+    it 'still includes mood and timestamp' do
+      result = client.narrate(tick_results: {}, cognitive_state: {})
+      expect(result[:mood]).to be_a(Symbol)
+      expect(result[:timestamp]).to be_a(Time)
+    end
+
+    it 'appends to journal' do
+      client.narrate(tick_results: {}, cognitive_state: {})
+      expect(client.journal.size).to eq(1)
+    end
+  end
+
+  describe '#narrate with LLM available but narrate returns nil' do
+    before 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)
+      stub_const('Legion::LLM', llm_double)
+    end
+
+    it 'falls back to mechanical pipeline' do
+      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 when LLM is unavailable' do
+    before { hide_const('Legion::LLM') }
+
+    it 'uses mechanical pipeline without source key' do
+      result = client.narrate(tick_results: {}, cognitive_state: {})
+      expect(result).not_to have_key(:source)
+      expect(result[:narrative]).to be_a(String)
+    end
+
+    it 'still generates mood and timestamp' do
+      result = client.narrate(tick_results: {}, cognitive_state: {})
+      expect(result[:mood]).to be_a(Symbol)
+      expect(result[:timestamp]).to be_a(Time)
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Runners::Narrator do
+  let(:client) { Legion::Extensions::Agentic::Language::Narrator::Client.new }
+
+  describe '#narrate' do
+    it 'generates and stores a narrative entry' do
+      result = client.narrate(
+        tick_results:    {
+          emotional_evaluation: { valence: 0.6, arousal: 0.7 },
+          sensory_processing:   { spotlight: 2, peripheral: 3 }
+        },
+        cognitive_state: {
+          curiosity: { intensity: 0.5, active_count: 2, top_question: 'What is happening?' }
+        }
+      )
+
+      expect(result[:narrative]).to be_a(String)
+      expect(result[:narrative]).to include('spotlight')
+      expect(result[:mood]).to be_a(Symbol)
+      expect(result[:timestamp]).to be_a(Time)
+      expect(result[:sections]).to be_a(Hash)
+    end
+
+    it 'appends to journal' do
+      client.narrate(tick_results: {}, cognitive_state: {})
+      expect(client.journal.size).to eq(1)
+    end
+
+    it 'accumulates entries over multiple narrations' do
+      3.times { client.narrate(tick_results: {}, cognitive_state: {}) }
+      expect(client.journal.size).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: {}) }
+    end
+
+    it 'returns recent entries' do
+      result = client.recent_entries(limit: 3)
+      expect(result[:entries].size).to eq(3)
+      expect(result[:count]).to eq(3)
+      expect(result[:total]).to eq(5)
+    end
+
+    it 'returns all when fewer than limit' do
+      result = client.recent_entries(limit: 20)
+      expect(result[:entries].size).to eq(5)
+    end
+  end
+
+  describe '#entries_since' do
+    it 'returns entries after timestamp' do
+      client.narrate(tick_results: {}, cognitive_state: {})
+      cutoff = Time.now.utc
+      sleep 0.01
+      client.narrate(tick_results: {}, cognitive_state: {})
+
+      result = client.entries_since(since: cutoff)
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#mood_history' do
+    before do
+      client.narrate(
+        tick_results:    { emotional_evaluation: { valence: 0.5, arousal: 0.8 } },
+        cognitive_state: {}
+      )
+      client.narrate(
+        tick_results:    { emotional_evaluation: { valence: -0.5, arousal: 0.8 } },
+        cognitive_state: {}
+      )
+      client.narrate(
+        tick_results:    { emotional_evaluation: { valence: 0.5, arousal: 0.8 } },
+        cognitive_state: {}
+      )
+    end
+
+    it 'returns all mood history without filter' do
+      result = client.mood_history
+      expect(result[:count]).to eq(3)
+    end
+
+    it 'filters by specific mood' do
+      result = client.mood_history(mood: :energized)
+      result[:entries].each { |e| expect(e[:mood]).to eq(:energized) }
+    end
+  end
+
+  describe '#current_narrative' do
+    it 'returns the most recent narrative' do
+      client.narrate(tick_results: { emotional_evaluation: { valence: 0.3 } }, cognitive_state: {})
+      result = client.current_narrative
+      expect(result[:narrative]).to be_a(String)
+      expect(result[:mood]).to be_a(Symbol)
+      expect(result[:age_seconds]).to be >= 0
+    end
+
+    it 'returns default when empty' do
+      result = client.current_narrative
+      expect(result[:narrative]).to include('No cognitive activity')
+      expect(result[:mood]).to eq(:dormant)
+    end
+  end
+
+  describe '#narrator_stats' do
+    it 'returns stats for empty journal' do
+      stats = client.narrator_stats
+      expect(stats[:journal_size]).to eq(0)
+      expect(stats[:capacity]).to eq(Legion::Extensions::Agentic::Language::Narrator::Helpers::Constants::MAX_JOURNAL_SIZE)
+    end
+
+    it 'tracks mood distribution' do
+      3.times do
+        client.narrate(tick_results: { emotional_evaluation: { valence: 0.5, arousal: 0.8 } }, cognitive_state: {})
+      end
+      stats = client.narrator_stats
+      expect(stats[:journal_size]).to eq(3)
+      expect(stats[:dominant_mood]).to eq(:energized)
+      expect(stats[:mood_counts][:energized]).to eq(3)
+    end
+  end
+end

data/spec/legion/extensions/agentic/language/pragmatic_inference/client_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/language/pragmatic_inference/client'
+
+RSpec.describe Legion::Extensions::Agentic::Language::PragmaticInference::Client do
+  it 'responds to all runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:analyze_utterance)
+    expect(client).to respond_to(:detect_maxim_violations)
+    expect(client).to respond_to(:generate_pragmatic_implicature)
+    expect(client).to respond_to(:speaker_pragmatic_profile)
+    expect(client).to respond_to(:utterances_by_speech_act)
+    expect(client).to respond_to(:utterances_by_speaker)
+    expect(client).to respond_to(:most_violated_maxim)
+    expect(client).to respond_to(:overall_cooperative_compliance)
+    expect(client).to respond_to(:update_pragmatic_inference)
+    expect(client).to respond_to(:pragmatic_inference_stats)
+  end
+end