flock-core 0.3.11__py3-none-any.whl → 0.3.14__py3-none-any.whl

flock/modules/memory/memory_module.py

@@ -1,21 +1,33 @@
-"""Memory module implementation for Flock agents."""
-
 import json
 import uuid
 from datetime import datetime
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import Field
+from tqdm import tqdm
 
 from flock.core import FlockAgent, FlockModule, FlockModuleConfig
 from flock.core.logging.logging import get_logger
 from flock.modules.memory.memory_parser import MemoryMappingParser
 from flock.modules.memory.memory_storage import FlockMemoryStore, MemoryEntry
 
+logger = get_logger("memory")
+
 
 class MemoryModuleConfig(FlockModuleConfig):
-    """Configuration for the memory module."""
+    """Configuration for the MemoryModule.
 
+    This class defines the configuration for the MemoryModule.
+    """
+
+    folder_path: str = Field(
+        default="concept_memory/",
+        description="Directory where memory file and concept graph will be saved",
+    )
+    concept_graph_file: str = Field(
+        default="concept_graph.png",
+        description="Base filename for the concept graph image",
+    )
     file_path: str | None = Field(
         default="agent_memory.json", description="Path to save memory file"
     )
@@ -25,26 +37,25 @@ class MemoryModuleConfig(FlockModuleConfig):
     similarity_threshold: float = Field(
         default=0.5, description="Threshold for semantic similarity"
     )
-    context_window: int = Field(
-        default=3, description="Number of memory entries to return"
-    )
     max_length: int = Field(
         default=1000, description="Max length of memory entry before splitting"
     )
     save_after_update: bool = Field(
         default=True, description="Whether to save memory after each update"
     )
-
-
-logger = get_logger("memory")
+    splitting_mode: Literal["summary", "semantic", "characters", "none"] = (
+        Field(default="none", description="Mode to split memory content")
+    )
+    enable_read_only_mode: bool = Field(
+        default=False, description="Whether to enable read only mode"
+    )
+    number_of_concepts_to_extract: int = Field(
+        default=3, description="Number of concepts to extract from the memory"
+    )
 
 
 class MemoryModule(FlockModule):
-    """Module that adds memory capabilities to a Flock agent.
-
-    This module encapsulates all memory-related functionality that was previously
-    hardcoded into FlockAgent.
-    """
+    """Module that adds memory capabilities to a Flock agent."""
 
     name: str = "memory"
     config: MemoryModuleConfig = Field(
@@ -52,31 +63,34 @@ class MemoryModule(FlockModule):
         description="Memory module configuration",
     )
     memory_store: FlockMemoryStore | None = None
-    memory_ops: list = []
+    memory_ops: list[Any] = []
+
+    def __init__(self, name: str, config: MemoryModuleConfig):
+        super().__init__(name=name, config=config)
+        self.memory_store = FlockMemoryStore.load_from_file(
+            self.get_memory_filename(name)
+        )
+        self.memory_ops = (
+            MemoryMappingParser().parse(self.config.memory_mapping)
+            if self.config.memory_mapping
+            else [{"type": "semantic"}]
+        )
 
-    async def pre_initialize(
+    async def initialize(
         self, agent: FlockAgent, inputs: dict[str, Any]
     ) -> None:
         """Initialize memory store if needed."""
         if not self.memory_store:
             self.memory_store = FlockMemoryStore.load_from_file(
-                self.config.file_path
+                self.get_memory_filename(self.name)
             )
-
-        if not self.config.memory_mapping:
-            self.memory_ops = []
-            self.memory_ops.append({"type": "semantic"})
-        else:
-            self.memory_ops = MemoryMappingParser().parse(
-                self.config.memory_mapping
-            )
-
+        self.memory_ops = (
+            MemoryMappingParser().parse(self.config.memory_mapping)
+            if self.config.memory_mapping
+            else [{"type": "semantic"}]
+        )
         logger.debug(f"Initialized memory module for agent {agent.name}")
 
-    async def post_initialize(self, agent: Any, inputs: dict[str, Any]) -> None:
-        """No post-initialization needed."""
-        pass
-
     async def pre_evaluate(
         self, agent: FlockAgent, inputs: dict[str, Any]
     ) -> dict[str, Any]:
@@ -85,12 +99,11 @@ class MemoryModule(FlockModule):
             return inputs
 
         try:
-            # Convert input to embedding
             input_text = json.dumps(inputs)
             query_embedding = self.memory_store.compute_embedding(input_text)
-
-            # Extract concepts
-            concepts = await self._extract_concepts(agent, input_text)
+            concepts = await self._extract_concepts(
+                agent, input_text, self.config.number_of_concepts_to_extract
+            )
 
             memory_results = []
             for op in self.memory_ops:
@@ -101,7 +114,6 @@ class MemoryModule(FlockModule):
                         similarity_threshold=self.config.similarity_threshold,
                     )
                     memory_results.extend(semantic_results)
-
                 elif op["type"] == "exact":
                     exact_results = self.memory_store.exact_match(inputs)
                     memory_results.extend(exact_results)
@@ -116,120 +128,270 @@ class MemoryModule(FlockModule):
             return inputs
 
         except Exception as e:
-            logger.warning(f"Memory retrieval failed: {e!s}", agent=agent.name)
+            logger.warning(f"Memory retrieval failed: {e}", agent=agent.name)
             return inputs
 
-    async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Store results in memory after evaluation."""
+    def get_memory_filename(self, module_name: str) -> str:
+        """Generate the full file path for the memory file."""
+        folder = self.config.folder_path
+        if not folder.endswith(("/", "\\")):
+            folder += "/"
+        import os
+
+        if not os.path.exists(folder):
+            os.makedirs(folder, exist_ok=True)
+        # Determine base filename and extension from file_path config
+        if self.config.file_path:
+            file_name = self.config.file_path.rsplit("/", 1)[-1].rsplit(
+                "\\", 1
+            )[-1]
+            if "." in file_name:
+                base, ext = file_name.rsplit(".", 1)
+                ext = f".{ext}"
+            else:
+                base, ext = file_name, ""
+        else:
+            base, ext = "agent_memory", ".json"
+        return f"{folder}{module_name}_{base}{ext}"
+
+    def get_concept_graph_filename(self, module_name: str) -> str:
+        """Generate the full file path for the concept graph image."""
+        folder = self.config.folder_path
+        if not folder.endswith(("/", "\\")):
+            folder += "/"
+        import os
+
+        if not os.path.exists(folder):
+            os.makedirs(folder, exist_ok=True)
+        # Use timestamp to create a unique filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
+        if self.config.concept_graph_file:
+            file_name = self.config.concept_graph_file.rsplit("/", 1)[
+                -1
+            ].rsplit("\\", 1)[-1]
+            if "." in file_name:
+                base, ext = file_name.rsplit(".", 1)
+                ext = f".{ext}"
+            else:
+                base, ext = file_name, ""
+        else:
+            base, ext = "concept_graph", ".png"
+        return f"{folder}{module_name}_{base}_{timestamp}{ext}"
+
+    async def search_memory(
+        self, agent: FlockAgent, query: dict[str, Any]
+    ) -> list[str]:
+        """Search memory for the query."""
         if not self.memory_store:
-            return result
+            return []
 
         try:
-            # Extract information chunks
-            chunks = await self._extract_information(agent, inputs, result)
-            chunk_concepts = await self._extract_concepts(agent, chunks)
-
-            # Create memory entry
-            entry = MemoryEntry(
-                id=str(uuid.uuid4()),
-                content=chunks,
-                embedding=self.memory_store.compute_embedding(chunks).tolist(),
-                concepts=chunk_concepts,
-                timestamp=datetime.now(),
+            input_text = json.dumps(query)
+            query_embedding = self.memory_store.compute_embedding(input_text)
+            concepts = await self._extract_concepts(
+                agent, input_text, self.config.number_of_concepts_to_extract
             )
 
-            # Add to memory store
-            self.memory_store.add_entry(entry)
+            memory_results = []
+            for op in self.memory_ops:
+                if op["type"] == "semantic":
+                    semantic_results = self.memory_store.retrieve(
+                        query_embedding,
+                        concepts,
+                        similarity_threshold=self.config.similarity_threshold,
+                    )
+                    memory_results.extend(semantic_results)
+                elif op["type"] == "exact":
+                    exact_results = self.memory_store.exact_match(query)
+                    memory_results.extend(exact_results)
+
+            if memory_results:
+                logger.debug(
+                    f"Found {len(memory_results)} relevant memories",
+                    agent=agent.name,
+                )
+                query["memory_results"] = memory_results
 
-            if self.config.save_after_update:
-                self.save_memory()
+            return query
 
-            logger.debug(
-                "Stored interaction in memory",
-                agent=agent.name,
-                entry_id=entry.id,
-                concepts=chunk_concepts,
-            )
+        except Exception as e:
+            logger.warning(f"Memory retrieval failed: {e}", agent=agent.name)
+            return query
 
+    async def add_to_memory(
+        self, agent: FlockAgent, data: dict[str, Any]
+    ) -> None:
+        """Add data to memory."""
+        if not self.memory_store:
+            return
+
+        try:
+            chunks = await self._get_chunks(agent, data, None)
+            await self._store_chunks(agent, chunks)
         except Exception as e:
-            logger.warning(f"Memory storage failed: {e!s}", agent=agent.name)
+            logger.warning(f"Memory storage failed: {e}", agent=agent.name)
 
-        return result
+    async def post_evaluate(
+        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Store results in memory after evaluation."""
+        if not self.memory_store:
+            return result
 
-    async def pre_terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
-    ) -> None:
-        """No pre-termination needed."""
-        pass
+        try:
+            chunks = await self._get_chunks(agent, inputs, result)
+            await self._store_chunks(agent, chunks)
+        except Exception as e:
+            logger.warning(f"Memory storage failed: {e}", agent=agent.name)
 
-    async def post_terminate(
+        return result
+
+    async def terminate(
         self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
     ) -> None:
         """Save memory store if configured."""
         if self.config.save_after_update and self.memory_store:
             self.save_memory()
 
-    async def _extract_concepts(self, agent: FlockAgent, text: str) -> set[str]:
-        """Extract concepts using agent's LLM capabilities."""
-        existing_concepts = None
-        if self.memory_store.concept_graph:
+    async def _extract_concepts(
+        self, agent: FlockAgent, text: str, number_of_concepts: int = 3
+    ) -> set[str]:
+        """Extract concepts using the agent's LLM capabilities."""
+        existing_concepts = set()
+        if self.memory_store and self.memory_store.concept_graph:
             existing_concepts = set(
                 self.memory_store.concept_graph.graph.nodes()
             )
 
-        input = "text: str | Text to analyze"
+        input_signature = "text: str | Text to analyze"
         if existing_concepts:
-            input += ", existing_concepts: list[str] | Already known concepts that might apply"
+            input_signature += ", existing_concepts: list[str] | Already known concepts that might apply"
 
-        # Create signature for concept extraction using agent's capabilities
         concept_signature = agent.create_dspy_signature_class(
             f"{agent.name}_concept_extractor",
             "Extract key concepts from text",
-            f"{input} -> concepts: list[str] | Max five key concepts all lower case",
+            f"{input_signature} -> concepts: list[str] | Max {number_of_concepts} key concepts all lower case",
         )
 
-        # Configure and run the predictor
-        agent._configure_language_model()
+        agent._configure_language_model(agent.model, True, 0.0, 8192)
         predictor = agent._select_task(concept_signature, "Completion")
-        result = predictor(
+        result_obj = predictor(
             text=text,
             existing_concepts=list(existing_concepts)
             if existing_concepts
             else None,
         )
-
-        concept_list = result.concepts if hasattr(result, "concepts") else []
+        concept_list = getattr(result_obj, "concepts", [])
         return set(concept_list)
 
-    async def _extract_information(
+    async def _summarize_mode(
         self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
     ) -> str:
-        """Extract information chunks from interaction."""
-        # Create splitter signature using agent's capabilities
+        """Extract information chunks using summary mode."""
         split_signature = agent.create_dspy_signature_class(
             f"{agent.name}_splitter",
             "Extract a list of potentially needed data and information for future reference",
             """
             content: str | The content to split
-            -> chunks: list[str] | list of data and information for future reference
+            -> chunks: list[str] | List of data and information for future reference
             """,
         )
-
-        # Configure and run the predictor
-        agent._configure_language_model()
+        agent._configure_language_model(agent.model, True, 0.0, 8192)
         splitter = agent._select_task(split_signature, "Completion")
-
-        # Get the content to split
         full_text = json.dumps(inputs) + json.dumps(result)
         split_result = splitter(content=full_text)
-
         return "\n".join(split_result.chunks)
 
+    async def _semantic_splitter_mode(
+        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+    ) -> str | list[dict[str, str]]:
+        """Extract information chunks using semantic mode."""
+        split_signature = agent.create_dspy_signature_class(
+            f"{self.name}_splitter",
+            "Split content into meaningful, self-contained chunks",
+            """
+            content: str | The content to split
+            -> chunks: list[dict[str,str]] | List of chunks as key-value pairs - keys are a short title and values are the chunk content
+            """,
+        )
+        agent._configure_language_model(agent.model, True, 0.0, 8192)
+        splitter = agent._select_task(split_signature, "Completion")
+        full_text = json.dumps(inputs) + (json.dumps(result) if result else "")
+        split_result = splitter(content=full_text)
+        return split_result.chunks
+
+    async def _character_splitter_mode(
+        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+    ) -> list[str]:
+        """Extract information chunks by splitting text into fixed character lengths."""
+        full_text = json.dumps(inputs) + (json.dumps(result) if result else "")
+        return [
+            full_text[i : i + self.config.max_length]
+            for i in range(0, len(full_text), self.config.max_length)
+        ]
+
+    async def _get_chunks(
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any] | None,
+    ) -> str | list[str]:
+        """Get memory chunks based on the configured splitting mode."""
+        mode = self.config.splitting_mode
+        if mode == "semantic":
+            return await self._semantic_splitter_mode(agent, inputs, result)
+        elif mode == "summary":
+            return await self._summarize_mode(agent, inputs, result)
+        elif mode == "characters":
+            return await self._character_splitter_mode(agent, inputs, result)
+        elif mode == "none":
+            return (
+                json.dumps(inputs) + json.dumps(result)
+                if result
+                else json.dumps(inputs)
+            )
+        else:
+            raise ValueError(f"Unknown splitting mode: {mode}")
+
+    async def _store_chunk(self, agent: FlockAgent, chunk: str) -> None:
+        """Store a single chunk in memory."""
+        chunk_concepts = await self._extract_concepts(
+            agent, chunk, self.config.number_of_concepts_to_extract
+        )
+        entry = MemoryEntry(
+            id=str(uuid.uuid4()),
+            content=chunk,
+            embedding=self.memory_store.compute_embedding(chunk).tolist(),
+            concepts=chunk_concepts,
+            timestamp=datetime.now(),
+        )
+        self.memory_store.add_entry(entry)
+        if self.config.save_after_update:
+            self.save_memory()
+        logger.debug(
+            "Stored interaction in memory",
+            agent=agent.name,
+            entry_id=entry.id,
+            concepts=chunk_concepts,
+        )
+
+    async def _store_chunks(
+        self, agent: FlockAgent, chunks: str | list[str]
+    ) -> None:
+        """Store chunks (single or multiple) in memory."""
+        if isinstance(chunks, str):
+            await self._store_chunk(agent, chunks)
+        elif isinstance(chunks, list):
+            for chunk in tqdm(chunks, desc="Storing chunks in memory"):
+                await self._store_chunk(agent, chunk)
+
     def save_memory(self) -> None:
         """Save memory store to file."""
         if self.memory_store and self.config.file_path:
             json_str = self.memory_store.model_dump_json()
-            with open(self.config.file_path, "w") as file:
+            filename = self.get_memory_filename(self.name)
+            with open(filename, "w") as file:
                 file.write(json_str)
+            self.memory_store.concept_graph.save_as_image(
+                self.get_concept_graph_filename(self.name)
+            )

flock/modules/memory/memory_parser.py

@@ -3,7 +3,7 @@
 import re
 from typing import Any
 
-from flock.core.memory.memory_storage import (
+from flock.modules.memory.memory_storage import (
     CombineOperation,
     EnrichOperation,
     ExactOperation,

flock/modules/output/output_module.py

@@ -54,6 +54,10 @@ class OutputModuleConfig(FlockModuleConfig):
         default_factory=dict,
         description="Custom formatters for specific output types",
     )
+    no_output: bool = Field(
+        default=False,
+        description="Whether to suppress output",
+    )
 
 
 class OutputModule(FlockModule):
@@ -159,6 +163,8 @@ class OutputModule(FlockModule):
     ) -> dict[str, Any]:
         """Format and display the output."""
         logger.debug("Formatting and displaying output")
+        if self.config.no_output:
+            return result
         # Display the result using the formatter
         self._formatter.display_result(result, agent.name)
 

{flock_core-0.3.11.dist-info → flock_core-0.3.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.11
+Version: 0.3.14
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -8,6 +8,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
+Requires-Dist: chromadb>=0.6.3
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: devtools>=0.12.2
 Requires-Dist: dspy==2.5.42

{flock_core-0.3.11.dist-info → flock_core-0.3.14.dist-info}/RECORD

@@ -10,9 +10,9 @@ flock/cli/load_release_notes.py,sha256=qFcgUrMddAE_TP6x1P-6ZywTUjTknfhTDW5LTxtg1
 flock/cli/settings.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 flock/cli/assets/release_notes.md,sha256=-RuE-G9Sn8z1LWEdr9iqjuQN7N1K_JMaCzHYoyLR42U,4793
 flock/core/__init__.py,sha256=mPlvKc0SxC2qCvSlgYeP_7EyV8ptmdn24NO8mlQoCSo,559
-flock/core/flock.py,sha256=Qch-6Z8XgLGzl-u5dbcXOOZYCqj40LjcAT0o22KrRE4,19263
-flock/core/flock_agent.py,sha256=MydN_A-oXKPJIJArHS61XSQnUjDktZovPkRuZOBokN4,11857
-flock/core/flock_api.py,sha256=SKQVKgFCaNCqHtwvIcksnpqG6ajHodVhs3oaKUw-d8c,7192
+flock/core/flock.py,sha256=IURlcuNvdsnqKkvgXtX4v_pGWQ8Lfb60X--MT0zvxHo,19881
+flock/core/flock_agent.py,sha256=qG6j-aSxSTEcvv5tjMyw3RTCaBooIGF7IVhAUOrhPOo,11946
+flock/core/flock_api.py,sha256=2rHnmEdtT5KPZYwGesRT7LqwbrgKClODHT-O56u7pcQ,7140
 flock/core/flock_evaluator.py,sha256=j7riJj_KsWoBnKmLiGp-U0CRhxDyJbgEdLGN26tfKm8,1588
 flock/core/flock_factory.py,sha256=nh0tK5UzEPWP5EmFrRvhsAeaZEvaPG5e0tkYkHpTjy0,2606
 flock/core/flock_module.py,sha256=3DmxOc39gQS-tiJcgUCjMaLr8QDDJR4acV_M76Xcf6I,2602
@@ -24,7 +24,7 @@ flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjayg
 flock/core/execution/temporal_executor.py,sha256=OF_uXgQsoUGp6U1ZkcuaidAEKyH7XDtbfrtdF10XQ_4,1675
 flock/core/interpreter/python_interpreter.py,sha256=RaUMZuufsKBNQ4FAeSaOgUuxzs8VYu5TgUUs-xwaxxM,26376
 flock/core/logging/__init__.py,sha256=Q8hp9-1ilPIUIV0jLgJ3_cP7COrea32cVwL7dicPnlM,82
-flock/core/logging/logging.py,sha256=RigZwiu5gsLMqHwhplGkGrmw74xe8M-5KLGIBSsjouY,7620
+flock/core/logging/logging.py,sha256=uWtUZnQI_sdtzLfXo61JPENSNNwplvEuGMPIhsYd-gQ,12448
 flock/core/logging/telemetry.py,sha256=3E9Tyj6AUR6A5RlIufcdCdWm5BAA7tbOsCa7lHoUQaU,5404
 flock/core/logging/trace_and_logged.py,sha256=5vNrK1kxuPMoPJ0-QjQg-EDJL1oiEzvU6UNi6X8FiMs,2117
 flock/core/logging/formatters/enum_builder.py,sha256=LgEYXUv84wK5vwHflZ5h8HBGgvLH3sByvUQe8tZiyY0,981
@@ -40,19 +40,22 @@ flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgw
 flock/core/registry/agent_registry.py,sha256=TUClh9e3eA6YzZC1CMTlsTPvQeqb9jYHewi-zPpcWM8,4987
 flock/core/serialization/secure_serializer.py,sha256=n5-zRvvXddgJv1FFHsaQ2wuYdL3WUSGPvG_LGaffEJo,6144
 flock/core/serialization/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
-flock/core/tools/basic_tools.py,sha256=fI9r81_ktRiRhNLwT-jSJ9rkjl28LC1ZfL-njnno2iw,4761
+flock/core/tools/basic_tools.py,sha256=idomjqvphTKIhuEkVS9CCJaigx_j_rv4jHqeDwp8sQY,5037
+flock/core/tools/llm_tools.py,sha256=Bdt4Dpur5dGpxd2KFEQyxjfZazvW1HCDKY6ydMj6UgQ,21811
+flock/core/tools/markdown_tools.py,sha256=W6fGM48yGHbifVlaOk1jOtVcybfRbRmf20VbDOZv8S4,6031
 flock/core/tools/dev_tools/github.py,sha256=a2OTPXS7kWOVA4zrZHynQDcsmEi4Pac5MfSjQOLePzA,5308
 flock/core/util/cli_helper.py,sha256=QSpP10WRNcjXzVFwpTQA8lSBy7707Qlv7uCit1XjUms,49808
 flock/core/util/hydrator.py,sha256=6qNwOwCZB7r6y25BZ--0PGofrAlfMaXbDKFQeP5NLts,11196
 flock/core/util/input_resolver.py,sha256=g9vDPdY4OH-G7qjas5ksGEHueokHGFPMoLOvC-ngeLo,5984
 flock/evaluators/declarative/declarative_evaluator.py,sha256=f8ldgZZp94zC4CoGzBufKvbvtckCGBe9EHTOoAZfZK0,1695
+flock/evaluators/memory/memory_evaluator.py,sha256=SmerXyNaqm8DTV0yw-WqWkn9DXIf6x-nPG1eyTV6NY8,3452
 flock/evaluators/natural_language/natural_language_evaluator.py,sha256=6nVEeh8_uwv_h-d3FWlA0GbzDzRtdhvxCGKirHtyvOU,2012
 flock/evaluators/zep/zep_evaluator.py,sha256=9NOELl7JAuUcx_FQrxY6b-_vN3MjwDyW7ZppPIGeCFc,1954
 flock/modules/callback/callback_module.py,sha256=hCCw-HNYjK4aHnUQfvw26ZP1Q_jdlKb9kDh3BHzbCQA,2916
-flock/modules/memory/memory_module.py,sha256=2grdmvw7FJWZvz0IjgASbDPCfyS1w4gWkRzOWtK7BFM,8214
-flock/modules/memory/memory_parser.py,sha256=2S7CmVEsm22gD7-MiFj4318FTg8wd_jB-RKMwXI14WM,4369
+flock/modules/memory/memory_module.py,sha256=z0MfMNpIsjL9NEXdfVofQ99z1ZaULQ1Fk3gp3SxEhd8,15246
+flock/modules/memory/memory_parser.py,sha256=FLH7GL8XThvHiCMfX3eQH7Sz-f62fzhAUmO6_gaDI7U,4372
 flock/modules/memory/memory_storage.py,sha256=CNcLDMmvv0x7Z3YMKr6VveS_VCa7rKPw8l2d-XgqokA,27246
-flock/modules/output/output_module.py,sha256=_Hid4ycGEl14m7GEsVGE9wp88SYkQ3eq_x4avUQcTWI,6985
+flock/modules/output/output_module.py,sha256=ygk553PxKulmoGlRL0F_iP_FMiDteEtAcz9zUfYYTdI,7153
 flock/modules/performance/metrics_module.py,sha256=JsLIVs-2PZ_A8GyYLNVBsNXdSFyrVid3YGd0fu4HXyM,16404
 flock/modules/zep/zep_module.py,sha256=BIJ5K-hg2bLeJmGKoDcVY1rVN7_0yYETiSaVrO-gtMI,5830
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
@@ -406,8 +409,8 @@ flock/workflow/activities.py,sha256=JDfcmn99k5UTN3QNm5hAdn_eRjWRYhWSIw1U0kMOAh4,
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.3.11.dist-info/METADATA,sha256=wgf_Y0msbblc7iVau5wGgYLqgHcwY9ap5fSXiponIRQ,20471
-flock_core-0.3.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.3.11.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.3.11.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.3.11.dist-info/RECORD,,
+flock_core-0.3.14.dist-info/METADATA,sha256=-baOqTXylWNerDitHki7cJoYtHFFS9x3k8VWf1S6-SI,20502
+flock_core-0.3.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.14.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.14.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.14.dist-info/RECORD,,