add CoreMemoryFunction,memory and test case

Author: graysonchen

spec/lib/ruby-openai-swarm/memories/core_memory_function_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+RSpec.describe OpenAISwarm::Memories::CoreMemoryFunction do
+  describe '.definition' do
+    # Test with empty memory fields
+    context 'when no memory fields are provided' do
+      it 'returns a function definition with empty properties' do
+        result = described_class.definition([])
+        
+        expect(result).to be_a(Hash)
+        expect(result[:type]).to eq('function')
+        expect(result[:function][:name]).to eq('core_memory_save')
+        expect(result[:function][:parameters][:properties]).to be_empty
+      end
+    end
+
+    # Test with memory fields
+    context 'when memory fields are provided' do
+      let(:memory_field) do
+        field = OpenAISwarm::Memories::Field.new('name')
+        field.tool_call_description = ' This is used to store the name.'
+        field
+      end
+
+      let(:memory_fields) { [memory_field] }
+
+      it 'returns a function definition with correct properties' do
+        result = described_class.definition(memory_fields)
+        
+        expect(result).to be_a(Hash)
+        expect(result[:type]).to eq('function')
+        expect(result[:function]).to include(
+          name: 'core_memory_save',
+          description: 'Save important information about you, the agent or the human you are chatting with.'
+        )
+
+        # Check properties structure
+        properties = result[:function][:parameters][:properties]
+        expect(properties).to include('name')
+        expect(properties['name']).to include(
+          type: 'string',
+          description: 'The name to remember. This is used to store the name.'
+        )
+      end
+    end
+
+    # Test with multiple memory fields
+    context 'when multiple memory fields are provided' do
+      let(:memory_fields) do
+        [
+          OpenAISwarm::Memories::Field.new('name'),
+          OpenAISwarm::Memories::Field.new('age')
+        ]
+      end
+
+      it 'includes all fields in the properties' do
+        result = described_class.definition(memory_fields)
+        properties = result[:function][:parameters][:properties]
+        
+        expect(properties.keys).to contain_exactly('name', 'age')
+        expect(properties['name'][:type]).to eq('string')
+        expect(properties['age'][:type]).to eq('string')
+      end
+    end
+  end
+end 

spec/lib/ruby-openai-swarm/memories/field_spec.rb

@@ -1,84 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe OpenAISwarm::Memories::Field do
-  let(:field_name) { :test_field }
-  let(:field_value) { "test value" }
-  let(:field) { described_class.new(field_name, field_value) }
-
-  describe '#initialize' do
-    it 'creates a field with name and value' do
-      expect(field.name).to eq(field_name)
-      expect(field.value).to eq(field_value)
-    end
-
-    it 'accepts different types of values' do
-      number_field = described_class.new(:number, 42)
-      expect(number_field.value).to eq(42)
-
-      array_field = described_class.new(:array, [1, 2, 3])
-      expect(array_field.value).to eq([1, 2, 3])
-
-      hash_field = described_class.new(:hash, { key: 'value' })
-      expect(hash_field.value).to eq({ key: 'value' })
-    end
-  end
-
-  describe '#to_h' do
-    it 'returns a hash representation of the field' do
-      expect(field.to_h).to eq({
-        name: field_name,
-        value: field_value
-      })
-    end
-  end
-
-  describe '#==' do
-    it 'returns true when comparing identical fields' do
-      field2 = described_class.new(field_name, field_value)
-      expect(field).to eq(field2)
-    end
-
-    it 'returns false when comparing fields with different names' do
-      field2 = described_class.new(:other_field, field_value)
-      expect(field).not_to eq(field2)
-    end
-
-    it 'returns false when comparing fields with different values' do
-      field2 = described_class.new(field_name, "other value")
-      expect(field).not_to eq(field2)
-    end
-  end
-
-  describe '#clone' do
-    it 'creates a deep copy of the field' do
-      cloned_field = field.clone
-      expect(cloned_field).to eq(field)
-      expect(cloned_field.object_id).not_to eq(field.object_id)
-    end
-
-    it 'creates independent copies of complex values' do
-      array_field = described_class.new(:array, [1, 2, 3])
-      cloned_field = array_field.clone
-      cloned_field.value << 4
-      expect(array_field.value).to eq([1, 2, 3])
-      expect(cloned_field.value).to eq([1, 2, 3, 4])
-    end
-  end
-
-  describe 'validation' do
-    it 'raises error when name is nil' do
-      expect {
-        described_class.new(nil, "value")
-      }.to raise_error(ArgumentError, "Field name cannot be nil")
-    end
-
-    it 'raises error when name is empty' do
-      expect {
-        described_class.new("", "value")
-      }.to raise_error(ArgumentError, "Field name cannot be empty")
-    end
-  end
-
   # Test initialization with a string
   describe '#initialize with string' do
     it 'sets the field value when initialized with a string' do

spec/lib/ruby-openai-swarm/memory_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+RSpec.describe OpenAISwarm::Memory do
+  # Test initialization and memory field normalization
+  describe '#initialize' do
+    context 'when initialized with memory fields' do
+      let(:memory_fields) { ['name', 'age'] }
+      let(:memory) { described_class.new(memory_fields: memory_fields) }
+
+      it 'creates normalized memory fields' do
+        expect(memory.instance_variable_get(:@memory_fields).size).to eq(2)
+        expect(memory.instance_variable_get(:@memory_fields).first).to be_a(OpenAISwarm::Memories::Field)
+      end
+    end
+
+    context 'when initialized without memory fields' do
+      let(:memory) { described_class.new }
+
+      it 'creates empty memory fields array' do
+        expect(memory.instance_variable_get(:@memory_fields)).to be_empty
+      end
+    end
+  end
+
+  # Test core memory save functionality
+  describe '#core_memory_save' do
+    let(:memory) { described_class.new(memory_fields: ['name']) }
+    let(:entities) { [{ 'name' => 'John Doe' }] }
+
+    it 'delegates entity addition to entity store' do
+      expect(memory.entity_store).to receive(:add_entities).with(entities)
+      memory.core_memory_save(entities)
+    end
+  end
+
+  # Test prompt content generation
+  describe '#prompt_content' do
+    context 'when memories exist' do
+      let(:memory_fields) { ['name', 'age'] }
+      let(:memory) { described_class.new(memory_fields: memory_fields) }
+      let(:memories_data) { "John Doe, 30" }
+
+      before do
+        allow(memory).to receive(:get_memories_data).and_return(memories_data)
+      end
+
+      it 'returns formatted prompt content with memories' do
+        expected_content = "You have a section of your context called [MEMORY] " \
+                          "that contains the following information: name, age. " \
+                          "Here are the relevant details: [MEMORY]\n" \
+                          "John Doe, 30"
+        expect(memory.prompt_content).to eq(expected_content)
+      end
+    end
+
+    context 'when no memories exist' do
+      let(:memory) { described_class.new }
+
+      before do
+        allow(memory).to receive(:get_memories_data).and_return(nil)
+      end
+
+      it 'returns nil' do
+        expect(memory.prompt_content).to be_nil
+      end
+    end
+  end
+
+  # Test function generation
+  describe '#function' do
+    context 'when memory fields exist' do
+      let(:memory) { described_class.new(memory_fields: ['name']) }
+
+      it 'returns a FunctionDescriptor instance' do
+        expect(memory.function).to be_a(OpenAISwarm::FunctionDescriptor)
+      end
+
+      it 'has correct target method' do
+        expect(memory.function.target_method).to eq(memory.method(:core_memory_save))
+      end
+    end
+
+    context 'when no memory fields exist' do
+      let(:memory) { described_class.new }
+
+      it 'returns nil' do
+        expect(memory.function).to be_nil
+      end
+    end
+  end
+
+  # Test memories data retrieval
+  describe '#get_memories_data' do
+    let(:memory) { described_class.new }
+
+    it 'delegates to entity store' do
+      expect(memory.entity_store).to receive(:memories)
+      memory.get_memories_data
+    end
+  end
+end