lex-agentic-memory 0.1.12 → 0.1.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f9d21093f342adfd656a2775f74aa1e53a397c16c484b4826bfa076d06799d7
-  data.tar.gz: 917b0430e8fe409bbe1e857d9e3989fe722405fc7a0c746de463663552aea51c
+  metadata.gz: 50c80158ba856d35e47e3c72fdfbadb29a4a75b0e45b1e859f507dafc850ab4d
+  data.tar.gz: e8ca09283855617c11b3cef8da5bdeec38a1aaeea526f1558610d1702ee8f97e
 SHA512:
-  metadata.gz: baa0bf1ac1b2e8b49af95680e021643df0c85fd1e9eed423fc41327d7aae4e52c93b951eed9662754469e9d2ed3df63be17d22793b91d7678e2cbf61a69aa841
-  data.tar.gz: 6463bbc07b183c771179ce3447b0846fb5b6b48065c16931c439ef5124e2e81091e13079a5c50ab6189acf5646c7fba010ae869949ef053de3612485aa21ec4c
+  metadata.gz: 9c7d4a3b2ba13f3639fcb6a6b8729ddef7e0e5286eaf2fb7a68fe5d4d395f6306e8dccf5d1a3c7ed2f884a49e2ddcb812f2377f0bca36384ad6231804d90a40b
+  data.tar.gz: d55c7a895b14acb28209eafba19b83059a1a89e84335d0e130968d941814c3af4ee66bb6d4c95a0d5c655bbe117b753f3240eee80f00cbbdccaa3e7479d322fd

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.1.14] - 2026-03-26
+
+### Fixed
+- `PostgresStore#serialize_trace` and `#map_update_fields` now strip null bytes (`\x00`) from all string fields before INSERT/UPDATE. PostgreSQL text columns reject null bytes, causing `string contains null byte` errors when content from external sources (e.g., Teams Graph API) contains embedded nulls
+
+## [0.1.13] - 2026-03-26
+
+### Fixed
+- `PostgresStore#serialize_trace` omitted `agent_id` column, causing `PG::NotNullViolation` on every insert against PostgreSQL (migration 022 declares `agent_id null: false`). Constructor now accepts `agent_id:` with fallback to `Legion::Settings.dig(:agent, :id)` or `'default'`
+- `Trace.create_store` factory now resolves and passes `agent_id` to PostgresStore
+- Spec schema for PostgresStore now includes `agent_id` column matching production migration
+
 ## [0.1.12] - 2026-03-26
 
 ### Fixed

data/lib/legion/extensions/agentic/memory/trace/helpers/postgres_store.rb

@@ -15,8 +15,9 @@ module Legion
               TRACES_TABLE = :memory_traces
               ASSOCIATIONS_TABLE = :memory_associations
 
-              def initialize(tenant_id: nil)
+              def initialize(tenant_id: nil, agent_id: nil)
                 @tenant_id = tenant_id
+                @agent_id  = agent_id || resolve_agent_id
               end
 
               # Store (upsert) a trace by trace_id.
@@ -262,6 +263,12 @@ module Legion
                 Legion::Data.connection
               end
 
+              def resolve_agent_id
+                Legion::Settings.dig(:agent, :id) || 'default'
+              rescue StandardError
+                'default'
+              end
+
               # Dataset for memory_traces scoped by tenant_id (if set).
               def traces_ds
                 ds = db[TRACES_TABLE]
@@ -277,29 +284,30 @@ module Legion
 
                 {
                   trace_id:                trace[:trace_id],
+                  agent_id:                @agent_id,
                   tenant_id:               @tenant_id,
-                  trace_type:              trace[:trace_type].to_s,
-                  content:                 payload.is_a?(Hash) ? Legion::JSON.dump(payload) : payload.to_s,
+                  trace_type:              sanitize_pg_string(trace[:trace_type].to_s),
+                  content:                 sanitize_pg_string(payload.is_a?(Hash) ? Legion::JSON.dump(payload) : payload.to_s),
                   significance:            conf,
                   confidence:              conf,
-                  associations:            assocs.is_a?(Array) ? Legion::JSON.dump(assocs) : '[]',
-                  domain_tags:             tags.is_a?(Array)   ? Legion::JSON.dump(tags)   : nil,
+                  associations:            sanitize_pg_string(assocs.is_a?(Array) ? Legion::JSON.dump(assocs) : '[]'),
+                  domain_tags:             sanitize_pg_string(tags.is_a?(Array) ? Legion::JSON.dump(tags) : nil),
                   strength:                trace[:strength],
                   peak_strength:           trace[:peak_strength],
                   base_decay_rate:         trace[:base_decay_rate],
                   emotional_valence:       ev.is_a?(Numeric) ? ev.to_f : 0.0,
                   emotional_intensity:     trace[:emotional_intensity],
-                  origin:                  trace[:origin].to_s,
-                  source_agent_id:         trace[:source_agent_id],
-                  storage_tier:            trace[:storage_tier].to_s,
+                  origin:                  sanitize_pg_string(trace[:origin].to_s),
+                  source_agent_id:         sanitize_pg_string(trace[:source_agent_id]),
+                  storage_tier:            sanitize_pg_string(trace[:storage_tier].to_s),
                   last_reinforced:         trace[:last_reinforced],
                   last_decayed:            trace[:last_decayed],
                   reinforcement_count:     trace[:reinforcement_count],
                   unresolved:              trace[:unresolved]              || false,
                   consolidation_candidate: trace[:consolidation_candidate] || false,
-                  parent_trace_id:         trace[:parent_trace_id],
-                  encryption_key_id:       trace[:encryption_key_id],
-                  partition_id:            trace[:partition_id],
+                  parent_trace_id:         sanitize_pg_string(trace[:parent_trace_id]),
+                  encryption_key_id:       sanitize_pg_string(trace[:encryption_key_id]),
+                  partition_id:            sanitize_pg_string(trace[:partition_id]),
                   created_at:              trace[:created_at] || Time.now.utc,
                   accessed_at:             Time.now.utc
                 }
@@ -351,13 +359,13 @@ module Legion
 
                   row[col] = case col
                              when :content
-                               v.is_a?(Hash) ? Legion::JSON.dump(v) : v.to_s
+                               sanitize_pg_string(v.is_a?(Hash) ? Legion::JSON.dump(v) : v.to_s)
                              when :associations
-                               v.is_a?(Array) ? Legion::JSON.dump(v) : '[]'
+                               sanitize_pg_string(v.is_a?(Array) ? Legion::JSON.dump(v) : '[]')
                              when :domain_tags
-                               v.is_a?(Array) ? Legion::JSON.dump(v) : nil
+                               sanitize_pg_string(v.is_a?(Array) ? Legion::JSON.dump(v) : nil)
                              when :trace_type, :origin, :storage_tier
-                               v.to_s
+                               sanitize_pg_string(v.to_s)
                              else
                                v
                              end
@@ -382,6 +390,12 @@ module Legion
                 []
               end
 
+              def sanitize_pg_string(value)
+                return value unless value.is_a?(String)
+
+                value.delete("\x00")
+              end
+
               def log_warn(message)
                 Legion::Logging.warn "[memory:postgres_store] #{message}" if defined?(Legion::Logging)
               end

data/lib/legion/extensions/agentic/memory/trace.rb

@@ -34,7 +34,7 @@ module Legion
             def create_store
               if postgres_available?
                 Legion::Logging.debug '[memory] Using shared PostgresStore (write-through)'
-                Helpers::PostgresStore.new(tenant_id: resolve_tenant_id)
+                Helpers::PostgresStore.new(tenant_id: resolve_tenant_id, agent_id: resolve_agent_id)
               elsif defined?(Legion::Cache) && Legion::Cache.respond_to?(:connected?) && Legion::Cache.connected?
                 Legion::Logging.debug '[memory] Using shared CacheStore (memcached)'
                 Helpers::CacheStore.new
@@ -60,6 +60,12 @@ module Legion
             rescue StandardError
               nil
             end
+
+            def resolve_agent_id
+              Legion::Settings.dig(:agent, :id) || 'default'
+            rescue StandardError
+              'default'
+            end
           end
         end
       end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Memory
-        VERSION = '0.1.12'
+        VERSION = '0.1.14'
       end
     end
   end

data/spec/legion/extensions/agentic/memory/trace/helpers/postgres_store_spec.rb

@@ -12,6 +12,7 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::PostgresStor
     d.create_table(:memory_traces) do
       primary_key :id
       String  :trace_id, size: 36, null: false, unique: true
+      String  :agent_id, size: 64, null: false, default: 'test-agent'
       String  :tenant_id, size: 64
       String  :trace_type, null: false
       String  :content, text: true, null: false
@@ -127,6 +128,23 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::PostgresStor
     end
   end
 
+  # --- store agent_id population ---
+
+  describe '#store agent_id population' do
+    it 'writes agent_id to the database row' do
+      store.store(semantic_trace)
+      row = db[:memory_traces].where(trace_id: semantic_trace[:trace_id]).first
+      expect(row[:agent_id]).not_to be_nil
+    end
+
+    it 'uses the resolved agent_id from settings' do
+      custom_store = described_class.new(tenant_id: tenant_id, agent_id: 'my-agent')
+      custom_store.store(semantic_trace)
+      row = db[:memory_traces].where(trace_id: semantic_trace[:trace_id]).first
+      expect(row[:agent_id]).to eq('my-agent')
+    end
+  end
+
   # --- store + retrieve ---
 
   describe '#store and #retrieve' do
@@ -167,6 +185,53 @@ RSpec.describe Legion::Extensions::Agentic::Memory::Trace::Helpers::PostgresStor
     end
   end
 
+  # --- null byte sanitization ---
+
+  describe 'null byte sanitization' do
+    it 'strips null bytes from string content and stores successfully' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: "hello\x00world")
+      result = store.store(trace)
+      expect(result).not_to be_nil
+
+      retrieved = store.retrieve(trace[:trace_id])
+      expect(retrieved[:content_payload]).to eq('helloworld')
+    end
+
+    it 'strips null bytes from hash content payloads' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: { text: "has\x00null" })
+      result = store.store(trace)
+      expect(result).not_to be_nil
+
+      row = db[:memory_traces].where(trace_id: trace[:trace_id]).first
+      expect(row[:content]).not_to include("\x00")
+    end
+
+    it 'strips null bytes from domain_tags' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: 'clean', domain_tags: ["tag\x00bad"])
+      store.store(trace)
+
+      row = db[:memory_traces].where(trace_id: trace[:trace_id]).first
+      expect(row[:domain_tags]).not_to include("\x00")
+    end
+
+    it 'stores cleanly when no null bytes are present' do
+      trace = trace_helper.new_trace(type: :episodic, content_payload: 'no nulls here')
+      result = store.store(trace)
+      expect(result).not_to be_nil
+
+      retrieved = store.retrieve(trace[:trace_id])
+      expect(retrieved[:content_payload]).to eq('no nulls here')
+    end
+
+    it 'strips null bytes during partial update' do
+      store.store(semantic_trace)
+      store.update(semantic_trace[:trace_id], content_payload: { text: "up\x00dated" })
+
+      row = db[:memory_traces].where(trace_id: semantic_trace[:trace_id]).first
+      expect(row[:content]).not_to include("\x00")
+    end
+  end
+
   # --- retrieve_by_type ---
 
   describe '#retrieve_by_type' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-memory
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.14
 platform: ruby
 authors:
 - Esity