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

flock/core/context/context.py

@@ -1,9 +1,10 @@
 import uuid
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict
 from datetime import datetime
 from typing import Any, Literal
 
 from opentelemetry import trace
+from pydantic import BaseModel, Field
 
 from flock.core.context.context_vars import FLOCK_LAST_AGENT, FLOCK_LAST_RESULT
 from flock.core.logging.logging import get_logger
@@ -13,34 +14,31 @@ logger = get_logger("context")
 tracer = trace.get_tracer(__name__)
 
 
-@dataclass
-class AgentRunRecord:
-    id: str = field(default="")
-    agent: str = field(default="")
-    data: dict[str, Any] = field(default_factory=dict)
-    timestamp: str = field(default="")
-    hand_off: dict = field(default_factory=dict)
-    called_from: str = field(default="")
+class AgentRunRecord(BaseModel):
+    id: str = Field(default="")
+    agent: str = Field(default="")
+    data: dict[str, Any] = Field(default_factory=dict)
+    timestamp: str = Field(default="")
+    hand_off: dict | None = Field(default_factory=dict)
+    called_from: str = Field(default="")
 
 
-@dataclass
-class AgentDefinition:
-    agent_type: str = field(default="")
-    agent_name: str = field(default="")
-    agent_data: dict = field(default_factory=dict)
-    serializer: Literal["json", "cloudpickle", "msgpack"] = field(
+class AgentDefinition(BaseModel):
+    agent_type: str = Field(default="")
+    agent_name: str = Field(default="")
+    agent_data: dict = Field(default_factory=dict)
+    serializer: Literal["json", "cloudpickle", "msgpack"] = Field(
         default="cloudpickle"
     )
 
 
-@dataclass
-class FlockContext(Serializable):
-    state: dict[str, Any] = field(default_factory=dict)
-    history: list[AgentRunRecord] = field(default_factory=list)
-    agent_definitions: dict[str, AgentDefinition] = field(default_factory=dict)
-    run_id: str = field(default="")
-    workflow_id: str = field(default="")
-    workflow_timestamp: str = field(default="")
+class FlockContext(Serializable, BaseModel):
+    state: dict[str, Any] = Field(default_factory=dict)
+    history: list[AgentRunRecord] = Field(default_factory=list)
+    agent_definitions: dict[str, AgentDefinition] = Field(default_factory=dict)
+    run_id: str = Field(default="")
+    workflow_id: str = Field(default="")
+    workflow_timestamp: str = Field(default="")
 
     def record(
         self,

flock/core/flock_agent.py

@@ -11,6 +11,7 @@ import cloudpickle
 from opentelemetry import trace
 from pydantic import BaseModel, Field
 
+from flock.core.context.context import FlockContext
 from flock.core.flock_evaluator import FlockEvaluator
 from flock.core.flock_module import FlockModule
 from flock.core.flock_router import FlockRouter
@@ -73,6 +74,11 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
         description="FlockModules attached to this agent",
     )
 
+    context: FlockContext | None = Field(
+        default=None,
+        description="Context associated with flock",
+    )
+
     def add_module(self, module: FlockModule) -> None:
         """Add a module to this agent."""
         self.modules[module.name] = module
@@ -95,6 +101,13 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
         with tracer.start_as_current_span("agent.initialize") as span:
             span.set_attribute("agent.name", self.name)
             span.set_attribute("inputs", str(inputs))
+            if not self.context:
+                self.context = FlockContext()
+
+            if self.name not in self.context.agent_definitions:
+                self.context.add_agent_definition(
+                    type(self), self.name, self.to_dict()
+                )
 
             try:
                 for module in self.get_enabled_modules():
@@ -102,7 +115,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
                         f"agent.initialize - module {module.name}",
                         agent=self.name,
                     )
-                    await module.initialize(self, inputs)
+                    await module.initialize(self, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during initialize",
@@ -124,7 +137,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             )
             try:
                 for module in self.get_enabled_modules():
-                    await module.terminate(self, inputs, inputs)
+                    await module.terminate(self, inputs, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during terminate",
@@ -139,7 +152,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             span.set_attribute("inputs", str(inputs))
             try:
                 for module in self.get_enabled_modules():
-                    await module.on_error(self, error, inputs)
+                    await module.on_error(self, error, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during on_error",
@@ -154,13 +167,15 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             span.set_attribute("inputs", str(inputs))
 
             for module in self.get_enabled_modules():
-                inputs = await module.pre_evaluate(self, inputs)
+                inputs = await module.pre_evaluate(self, inputs, self.context)
 
             try:
                 result = await self.evaluator.evaluate(self, inputs, self.tools)
 
                 for module in self.get_enabled_modules():
-                    result = await module.post_evaluate(self, inputs, result)
+                    result = await module.post_evaluate(
+                        self, inputs, result, self.context
+                    )
 
                 span.set_attribute("result", str(result))
 

flock/core/flock_factory.py

@@ -34,6 +34,8 @@ class FlockFactory:
         temperature: float = 0.0,
         max_tokens: int = 4096,
         alert_latency_threshold_ms: int = 30000,
+        no_output: bool = False,
+        print_context: bool = False,
     ) -> FlockAgent:
         """Creates a default FlockAgent.
 
@@ -63,6 +65,8 @@ class FlockFactory:
             render_table=enable_rich_tables,
             theme=output_theme,
             wait_for_input=wait_for_input,
+            no_output=no_output,
+            print_context=print_context,
         )
         output_module = OutputModule("output", config=output_config)
 

flock/core/flock_module.py

@@ -5,6 +5,8 @@ from typing import Any, TypeVar
 
 from pydantic import BaseModel, Field, create_model
 
+from flock.core.context.context import FlockContext
+
 T = TypeVar("T", bound="FlockModuleConfig")
 
 
@@ -50,30 +52,50 @@ class FlockModule(BaseModel, ABC):
         default_factory=FlockModuleConfig, description="Module configuration"
     )
 
-    async def initialize(self, agent: Any, inputs: dict[str, Any]) -> None:
+    async def initialize(
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+    ) -> None:
         """Called when the agent starts running."""
         pass
 
     async def pre_evaluate(
-        self, agent: Any, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Called before agent evaluation, can modify inputs."""
         return inputs
 
     async def post_evaluate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Called after agent evaluation, can modify results."""
         return result
 
     async def terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Called when the agent finishes running."""
         pass
 
     async def on_error(
-        self, agent: Any, error: Exception, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        error: Exception,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Called when an error occurs during agent execution."""
         pass

flock/core/tools/basic_tools.py

@@ -43,6 +43,30 @@ def web_search_duckduckgo(
         raise
 
 
+@traced_and_logged
+def web_search_bing(keywords: str):
+    try:
+        import httpx
+
+        subscription_key = os.environ["BING_SEARCH_V7_SUBSCRIPTION_KEY"]
+        endpoint = "https://api.bing.microsoft.com/v7.0/search"
+
+        # Query term(s) to search for.
+        query = keywords
+
+        # Construct a request
+        mkt = "en-US"
+        params = {"q": query, "mkt": mkt}
+        headers = {"Ocp-Apim-Subscription-Key": subscription_key}
+
+        response = httpx.get(endpoint, headers=headers, params=params)
+        response.raise_for_status()
+        search_results = response.json()
+        return search_results["webPages"]
+    except Exception:
+        raise
+
+
 def extract_links_from_markdown(markdown: str, url: str) -> list:
     # Regular expression to find all markdown links
     link_pattern = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")

flock/modules/callback/callback_module.py

@@ -6,6 +6,7 @@ from typing import Any
 from pydantic import Field
 
 from flock.core import FlockModule, FlockModuleConfig
+from flock.core.context.context import FlockContext
 
 
 class CallbackModuleConfig(FlockModuleConfig):
@@ -44,13 +45,21 @@ class CallbackModule(FlockModule):
         description="Callback module configuration",
     )
 
-    async def pre_initialize(self, agent: Any, inputs: dict[str, Any]) -> None:
+    async def pre_initialize(
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+    ) -> None:
         """Run initialize callback if configured."""
         if self.config.initialize_callback:
             await self.config.initialize_callback(agent, inputs)
 
     async def pre_evaluate(
-        self, agent: Any, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Run evaluate callback if configured."""
         if self.config.evaluate_callback:
@@ -58,29 +67,23 @@ class CallbackModule(FlockModule):
         return inputs
 
     async def pre_terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Run terminate callback if configured."""
         if self.config.terminate_callback:
             await self.config.terminate_callback(agent, inputs, result)
 
     async def on_error(
-        self, agent: Any, error: Exception, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        error: Exception,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Run error callback if configured."""
         if self.config.on_error_callback:
             await self.config.on_error_callback(agent, error, inputs)
-
-    # Other hooks just pass through
-    async def post_initialize(self, agent: Any, inputs: dict[str, Any]) -> None:
-        pass
-
-    async def post_evaluate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
-    ) -> dict[str, Any]:
-        return result
-
-    async def post_terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
-    ) -> None:
-        pass

flock/modules/memory/memory_module.py

@@ -7,6 +7,7 @@ from pydantic import Field
 from tqdm import tqdm
 
 from flock.core import FlockAgent, FlockModule, FlockModuleConfig
+from flock.core.context.context import FlockContext
 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
@@ -77,7 +78,10 @@ class MemoryModule(FlockModule):
         )
 
     async def initialize(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Initialize memory store if needed."""
         if not self.memory_store:
@@ -92,44 +96,23 @@ class MemoryModule(FlockModule):
         logger.debug(f"Initialized memory module for agent {agent.name}")
 
     async def pre_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Check memory before evaluation."""
         if not self.memory_store:
             return inputs
 
-        try:
-            input_text = json.dumps(inputs)
-            query_embedding = self.memory_store.compute_embedding(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:
-                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(inputs)
-                    memory_results.extend(exact_results)
-
-            if memory_results:
-                logger.debug(
-                    f"Found {len(memory_results)} relevant memories",
-                    agent=agent.name,
-                )
-                inputs["memory_results"] = memory_results
+        inputs = await self.search_memory(agent, inputs)
 
-            return inputs
+        if "context" in inputs:
+            agent.input = (
+                agent.input + ", context: list | context with more information"
+            )
 
-        except Exception as e:
-            logger.warning(f"Memory retrieval failed: {e}", agent=agent.name)
-            return inputs
+        return inputs
 
     def get_memory_filename(self, module_name: str) -> str:
         """Generate the full file path for the memory file."""
@@ -205,12 +188,18 @@ class MemoryModule(FlockModule):
                     exact_results = self.memory_store.exact_match(query)
                     memory_results.extend(exact_results)
 
+            context: list[dict[str, Any]] = []
             if memory_results:
+                for result in memory_results:
+                    context.append(
+                        {"content": result.content, "concepts": result.concepts}
+                    )
+
                 logger.debug(
                     f"Found {len(memory_results)} relevant memories",
                     agent=agent.name,
                 )
-                query["memory_results"] = memory_results
+                query["context"] = context
 
             return query
 
@@ -232,7 +221,11 @@ class MemoryModule(FlockModule):
             logger.warning(f"Memory storage failed: {e}", agent=agent.name)
 
     async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Store results in memory after evaluation."""
         if not self.memory_store:
@@ -247,7 +240,11 @@ class MemoryModule(FlockModule):
         return result
 
     async def terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Save memory store if configured."""
         if self.config.save_after_update and self.memory_store:

flock/modules/output/output_module.py

@@ -8,6 +8,7 @@ from typing import Any
 from pydantic import Field
 
 from flock.core import FlockAgent
+from flock.core.context.context import FlockContext
 from flock.core.flock_module import FlockModule, FlockModuleConfig
 from flock.core.logging.formatters.themed_formatter import (
     ThemedAgentResultFormatter,
@@ -58,6 +59,10 @@ class OutputModuleConfig(FlockModuleConfig):
         default=False,
         description="Whether to suppress output",
     )
+    print_context: bool = Field(
+        default=False,
+        description="Whether to print the context",
+    )
 
 
 class OutputModule(FlockModule):
@@ -159,12 +164,18 @@ class OutputModule(FlockModule):
             json.dump(output_data, f, indent=2)
 
     async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Format and display the output."""
         logger.debug("Formatting and displaying output")
         if self.config.no_output:
             return result
+        if self.config.print_context:
+            result["context"] = context
         # Display the result using the formatter
         self._formatter.display_result(result, agent.name)
 

flock/modules/performance/metrics_module.py

@@ -11,6 +11,7 @@ import numpy as np
 import psutil
 from pydantic import BaseModel, Field, validator
 
+from flock.core.context.context import FlockContext
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_module import FlockModule, FlockModuleConfig
 
@@ -222,7 +223,11 @@ class MetricsModule(FlockModule):
         return stats
 
     async def terminate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Clean up and final metric recording."""
         if self.config.storage_type == "json":
@@ -331,7 +336,10 @@ class MetricsModule(FlockModule):
         return False
 
     async def initialize(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Initialize metrics collection."""
         self._start_time = time.time()
@@ -370,7 +378,10 @@ class MetricsModule(FlockModule):
             return token_count, total_cost
 
     async def pre_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Record pre-evaluation metrics."""
         if self.config.collect_token_usage:
@@ -408,7 +419,11 @@ class MetricsModule(FlockModule):
         return inputs
 
     async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Record post-evaluation metrics."""
         if self.config.collect_timing and self._start_time:
@@ -463,7 +478,11 @@ class MetricsModule(FlockModule):
         return result
 
     async def on_error(
-        self, agent: FlockAgent, error: Exception, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        error: Exception,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Record error metrics."""
         self._record_metric(

flock/modules/zep/zep_module.py

@@ -5,6 +5,7 @@ from pydantic import Field
 from zep_python.client import Zep
 from zep_python.types import Message as ZepMessage, SessionSearchResult
 
+from flock.core.context.context import FlockContext
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_module import FlockModule, FlockModuleConfig
 from flock.core.logging.logging import get_logger
@@ -139,7 +140,11 @@ class ZepModule(FlockModule):
         return response.results
 
     async def post_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Format and display the output."""
         if not self.config.enable_write:
@@ -152,7 +157,10 @@ class ZepModule(FlockModule):
         return result
 
     async def pre_evaluate(
-        self, agent: FlockAgent, inputs: dict[str, Any]
+        self,
+        agent: FlockAgent,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Format and display the output."""
         if not self.config.enable_read:

flock/workflow/activities.py

@@ -50,7 +50,7 @@ async def run_agent(context: FlockContext) -> dict:
             # Create a nested span for this iteration.
             with tracer.start_as_current_span("agent_iteration") as iter_span:
                 iter_span.set_attribute("agent.name", agent.name)
-
+                agent.context = context
                 # Resolve inputs for the agent.
                 agent_inputs = resolve_inputs(
                     agent.input, context, previous_agent_name
@@ -160,7 +160,7 @@ async def run_agent(context: FlockContext) -> dict:
                     agent.name,
                     result,
                     timestamp=datetime.now().isoformat(),
-                    hand_off=handoff_data,
+                    hand_off=handoff_data.model_dump(),
                     called_from=previous_agent_name,
                 )
                 previous_agent_name = agent.name

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.14
+Version: 0.3.16
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

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

@@ -11,13 +11,13 @@ 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=IURlcuNvdsnqKkvgXtX4v_pGWQ8Lfb60X--MT0zvxHo,19881
-flock/core/flock_agent.py,sha256=qG6j-aSxSTEcvv5tjMyw3RTCaBooIGF7IVhAUOrhPOo,11946
+flock/core/flock_agent.py,sha256=QPyRSa1X_aAK2MSgqLNHBiL-_cnYHOSSnrFup2YTzss,12509
 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
+flock/core/flock_factory.py,sha256=7nV0WAh197INdBckJ-NhnhSSZOSzZC1MlYfeZm2x8Xc,2750
+flock/core/flock_module.py,sha256=96aFVYAgwpKN53xGbivQDUpikOYGFCxK5mqhclOcxY0,3003
 flock/core/flock_router.py,sha256=A5GaxcGvtiFlRLHBTW7okh5RDm3BdKam2uXvRHRaj7k,2187
-flock/core/context/context.py,sha256=AW0qKIAkgZucVroGsulrPVPc4WmWuqWIrVPHf2qaOLI,6380
+flock/core/context/context.py,sha256=3sj5BrnY7OBG8Xk-uoT0yPKQjCzUU6a3VH26xuHo2KI,6407
 flock/core/context/context_manager.py,sha256=FANSWa6DEhdhtZ7t_9Gza0v80UdpoDOhHbfVOccmjkA,1181
 flock/core/context/context_vars.py,sha256=zYTMi9b6mNSSEHowEQUOTpEDurmAjaUcyBCgfKY6-cU,300
 flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjaygl_Db0M8ao,952
@@ -40,7 +40,7 @@ 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=idomjqvphTKIhuEkVS9CCJaigx_j_rv4jHqeDwp8sQY,5037
+flock/core/tools/basic_tools.py,sha256=P1-RWkw57U2vSxPTCd5awlNg4MME4GkBLEB5HiiKmkw,5715
 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
@@ -48,16 +48,18 @@ flock/core/util/cli_helper.py,sha256=QSpP10WRNcjXzVFwpTQA8lSBy7707Qlv7uCit1XjUms
 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/azure_search_evaluator.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=z0MfMNpIsjL9NEXdfVofQ99z1ZaULQ1Fk3gp3SxEhd8,15246
+flock/modules/azure-search/azure_search_module.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flock/modules/callback/callback_module.py,sha256=volGGgHtY19qj1wHR6m5a_hmXSbV3Ca3uY6I76YmcfU,2833
+flock/modules/memory/memory_module.py,sha256=dZ30eOFqIlAz0a5IKJMoXgJ-VyPEqApAOX0OQjhGA1I,14733
 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=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/modules/output/output_module.py,sha256=MPs5QV5g5DZQGqR07dS0eBug_TGpkdjX5zTrcrDphq8,7467
+flock/modules/performance/metrics_module.py,sha256=UD9OjY4-zAvauMD7YyDYqE1gyIhzpdr3JkBT8j9knxY,16790
+flock/modules/zep/zep_module.py,sha256=x7JG6O6xnwwum0RETIqKYbA3xzdcvX2aUuns0Cl0c2Q,6014
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
 flock/platform/jaeger_install.py,sha256=MyOMJQx4TQSMYvdUJxfiGSo3YCtsfkbNXcAcQ9bjETA,2898
 flock/routers/__init__.py,sha256=w9uL34Auuo26-q_EGlE8Z9iHsw6S8qutTAH_ZI7pn7M,39
@@ -405,12 +407,12 @@ flock/themes/zenburned.toml,sha256=UEmquBbcAO3Zj652XKUwCsNoC2iQSlIh-q5c6DH-7Kc,1
 flock/themes/zenwritten-dark.toml,sha256=To5l6520_3UqAGiEumpzGWsHhXxqu9ThrMildXKgIO0,1669
 flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolUYolmE,1666
 flock/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/workflow/activities.py,sha256=JDfcmn99k5UTN3QNm5hAdn_eRjWRYhWSIw1U0kMOAh4,9014
+flock/workflow/activities.py,sha256=yah-lHjMW6_Ww1gt7hMXBis1cJRlcbHx0uLsMB9oNZ0,9066
 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.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,,
+flock_core-0.3.16.dist-info/METADATA,sha256=ufURDAvefWtPcOW36ewLIRKwXuqkdIaHCFD_LMlGWAk,20502
+flock_core-0.3.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.16.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.16.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.16.dist-info/RECORD,,