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

flock/cli/assets/release_notes.md

@@ -69,6 +69,7 @@ Like a hummingbird, modules are small and nimble code packages. Put enough of th
 - **Output Module** – Advanced output formatting and storage  
 - **Metrics Module** – Detailed performance tracking  
 - **Zep Module** – Uses Zep for Knowledge Graphs
+- **Azure Search Tools** – Integration with Azure AI Search for vector search and document retrieval
 
 ---
 

flock/core/tools/azure_tools.py

@@ -0,0 +1,496 @@
+import os
+from typing import Any
+
+from azure.core.credentials import AzureKeyCredential
+from azure.search.documents import SearchClient
+from azure.search.documents.indexes import SearchIndexClient
+from azure.search.documents.indexes.models import (
+    ExhaustiveKnnAlgorithmConfiguration,
+    HnswAlgorithmConfiguration,
+    SearchableField,
+    SearchField,
+    SearchFieldDataType,
+    SearchIndex,
+    SimpleField,
+    VectorSearch,
+    VectorSearchProfile,
+)
+from azure.search.documents.models import VectorizedQuery
+
+from flock.core.logging.trace_and_logged import traced_and_logged
+
+
+def _get_default_endpoint() -> str:
+    """Get the default Azure Search endpoint from environment variables."""
+    endpoint = os.environ.get("AZURE_SEARCH_ENDPOINT")
+    if not endpoint:
+        raise ValueError(
+            "AZURE_SEARCH_ENDPOINT environment variable is not set"
+        )
+    return endpoint
+
+
+def _get_default_api_key() -> str:
+    """Get the default Azure Search API key from environment variables."""
+    api_key = os.environ.get("AZURE_SEARCH_API_KEY")
+    if not api_key:
+        raise ValueError("AZURE_SEARCH_API_KEY environment variable is not set")
+    return api_key
+
+
+def _get_default_index_name() -> str:
+    """Get the default Azure Search index name from environment variables."""
+    index_name = os.environ.get("AZURE_SEARCH_INDEX_NAME")
+    if not index_name:
+        raise ValueError(
+            "AZURE_SEARCH_INDEX_NAME environment variable is not set"
+        )
+    return index_name
+
+
+@traced_and_logged
+def azure_search_initialize_clients(
+    endpoint: str | None = None,
+    api_key: str | None = None,
+    index_name: str | None = None,
+) -> dict[str, Any]:
+    """Initialize Azure AI Search clients.
+
+    Args:
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+        index_name: Optional index name for SearchClient initialization (defaults to AZURE_SEARCH_INDEX_NAME env var if not None)
+
+    Returns:
+        Dictionary containing the initialized clients
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+
+    credential = AzureKeyCredential(api_key)
+
+    # Create the search index client
+    search_index_client = SearchIndexClient(
+        endpoint=endpoint, credential=credential
+    )
+
+    # Create clients dictionary
+    clients = {
+        "index_client": search_index_client,
+    }
+
+    # Add search client if index_name was provided or available in env
+    if index_name is None and os.environ.get("AZURE_SEARCH_INDEX_NAME"):
+        index_name = _get_default_index_name()
+
+    if index_name:
+        search_client = SearchClient(
+            endpoint=endpoint, index_name=index_name, credential=credential
+        )
+        clients["search_client"] = search_client
+
+    return clients
+
+
+@traced_and_logged
+def azure_search_create_index(
+    index_name: str | None = None,
+    fields: list[SearchField] = None,
+    vector_search: VectorSearch | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Create a new search index in Azure AI Search.
+
+    Args:
+        index_name: Name of the search index to create (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        fields: List of field definitions for the index
+        vector_search: Optional vector search configuration
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary containing information about the created index
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    if fields is None:
+        raise ValueError("Fields must be provided for index creation")
+
+    clients = azure_search_initialize_clients(endpoint, api_key)
+    index_client = clients["index_client"]
+
+    # Create the index
+    index = SearchIndex(
+        name=index_name, fields=fields, vector_search=vector_search
+    )
+
+    result = index_client.create_or_update_index(index)
+
+    return {
+        "index_name": result.name,
+        "fields": [field.name for field in result.fields],
+        "created": True,
+    }
+
+
+@traced_and_logged
+def azure_search_upload_documents(
+    documents: list[dict[str, Any]],
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Upload documents to an Azure AI Search index.
+
+    Args:
+        documents: List of documents to upload (as dictionaries)
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary containing the upload results
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    result = search_client.upload_documents(documents=documents)
+
+    # Process results
+    succeeded = sum(1 for r in result if r.succeeded)
+
+    return {
+        "succeeded": succeeded,
+        "failed": len(result) - succeeded,
+        "total": len(result),
+    }
+
+
+@traced_and_logged
+def azure_search_query(
+    search_text: str | None = None,
+    filter: str | None = None,
+    select: list[str] | None = None,
+    top: int | None = 50,
+    vector: list[float] | None = None,
+    vector_field: str | None = None,
+    vector_k: int | None = 10,
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> list[dict[str, Any]]:
+    """Search documents in an Azure AI Search index.
+
+    Args:
+        search_text: Optional text to search for (keyword search)
+        filter: Optional OData filter expression
+        select: Optional list of fields to return
+        top: Maximum number of results to return
+        vector: Optional vector for vector search
+        vector_field: Name of the field containing vectors for vector search
+        vector_k: Number of nearest neighbors to retrieve in vector search
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        List of search results as dictionaries
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    # Set up vector query if vector is provided
+    vectorized_query = None
+    if vector and vector_field:
+        vectorized_query = VectorizedQuery(
+            vector=vector, k=vector_k, fields=[vector_field]
+        )
+
+    # Execute the search
+    results = search_client.search(
+        search_text=search_text,
+        filter=filter,
+        select=select,
+        top=top,
+        vector_queries=[vectorized_query] if vectorized_query else None,
+    )
+
+    # Convert results to list of dictionaries
+    result_list = [dict(result) for result in results]
+
+    return result_list
+
+
+@traced_and_logged
+def azure_search_get_document(
+    key: str,
+    select: list[str] | None = None,
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Retrieve a specific document from an Azure AI Search index by key.
+
+    Args:
+        key: The unique key of the document to retrieve
+        select: Optional list of fields to return
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        The retrieved document as a dictionary
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    result = search_client.get_document(key=key, selected_fields=select)
+
+    return dict(result)
+
+
+@traced_and_logged
+def azure_search_delete_documents(
+    keys: list[str],
+    key_field_name: str = "id",
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Delete documents from an Azure AI Search index.
+
+    Args:
+        keys: List of document keys to delete
+        key_field_name: Name of the key field (defaults to "id")
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary containing the deletion results
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    # Format documents for deletion (only need the key field)
+    documents_to_delete = [{key_field_name: key} for key in keys]
+
+    result = search_client.delete_documents(documents=documents_to_delete)
+
+    # Process results
+    succeeded = sum(1 for r in result if r.succeeded)
+
+    return {
+        "succeeded": succeeded,
+        "failed": len(result) - succeeded,
+        "total": len(result),
+    }
+
+
+@traced_and_logged
+def azure_search_list_indexes(
+    endpoint: str | None = None, api_key: str | None = None
+) -> list[dict[str, Any]]:
+    """List all indexes in the Azure AI Search service.
+
+    Args:
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        List of indexes as dictionaries
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+
+    clients = azure_search_initialize_clients(endpoint, api_key)
+    index_client = clients["index_client"]
+
+    result = index_client.list_indexes()
+
+    # Convert index objects to dictionaries with basic information
+    indexes = [
+        {
+            "name": index.name,
+            "fields": [field.name for field in index.fields],
+            "field_count": len(index.fields),
+        }
+        for index in result
+    ]
+
+    return indexes
+
+
+@traced_and_logged
+def azure_search_get_index_statistics(
+    index_name: str | None = None,
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Get statistics for a specific Azure AI Search index.
+
+    Args:
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary containing index statistics
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key, index_name)
+    search_client = clients["search_client"]
+
+    stats = search_client.get_document_count()
+
+    return {"document_count": stats}
+
+
+@traced_and_logged
+def azure_search_create_vector_index(
+    fields: list[dict[str, Any]],
+    vector_dimensions: int,
+    index_name: str | None = None,
+    algorithm_kind: str = "hnsw",
+    endpoint: str | None = None,
+    api_key: str | None = None,
+) -> dict[str, Any]:
+    """Create a vector search index in Azure AI Search.
+
+    Args:
+        fields: List of field configurations (dicts with name, type, etc.)
+        vector_dimensions: Dimensions of the vector field
+        index_name: Name of the search index (defaults to AZURE_SEARCH_INDEX_NAME env var)
+        algorithm_kind: Vector search algorithm ("hnsw" or "exhaustive")
+        endpoint: The Azure AI Search service endpoint URL (defaults to AZURE_SEARCH_ENDPOINT env var)
+        api_key: The Azure AI Search API key (defaults to AZURE_SEARCH_API_KEY env var)
+
+    Returns:
+        Dictionary with index creation result
+    """
+    # Use environment variables as defaults if not provided
+    endpoint = endpoint or _get_default_endpoint()
+    api_key = api_key or _get_default_api_key()
+    index_name = index_name or _get_default_index_name()
+
+    clients = azure_search_initialize_clients(endpoint, api_key)
+    index_client = clients["index_client"]
+
+    # Convert field configurations to SearchField objects
+    index_fields = []
+    vector_fields = []
+
+    for field_config in fields:
+        field_name = field_config["name"]
+        field_type = field_config["type"]
+        field_searchable = field_config.get("searchable", False)
+        field_filterable = field_config.get("filterable", False)
+        field_sortable = field_config.get("sortable", False)
+        field_key = field_config.get("key", False)
+        field_vector = field_config.get("vector", False)
+
+        if field_searchable and field_type == "string":
+            field = SearchableField(
+                name=field_name,
+                type=SearchFieldDataType.String,
+                key=field_key,
+                filterable=field_filterable,
+                sortable=field_sortable,
+            )
+        else:
+            data_type = None
+            if field_type == "string":
+                data_type = SearchFieldDataType.String
+            elif field_type == "int":
+                data_type = SearchFieldDataType.Int32
+            elif field_type == "double":
+                data_type = SearchFieldDataType.Double
+            elif field_type == "boolean":
+                data_type = SearchFieldDataType.Boolean
+            elif field_type == "collection":
+                data_type = SearchFieldDataType.Collection(
+                    SearchFieldDataType.String
+                )
+
+            field = SimpleField(
+                name=field_name,
+                type=data_type,
+                key=field_key,
+                filterable=field_filterable,
+                sortable=field_sortable,
+            )
+
+        index_fields.append(field)
+
+        if field_vector:
+            vector_fields.append(field_name)
+
+    # Set up vector search configuration
+    algorithm_config = None
+    if algorithm_kind.lower() == "hnsw":
+        algorithm_config = HnswAlgorithmConfiguration(
+            name="hnsw-config",
+            parameters={"m": 4, "efConstruction": 400, "efSearch": 500},
+        )
+    else:
+        algorithm_config = ExhaustiveKnnAlgorithmConfiguration(
+            name="exhaustive-config"
+        )
+
+    # Create vector search configuration
+    vector_search = VectorSearch(
+        algorithms=[algorithm_config],
+        profiles=[
+            VectorSearchProfile(
+                name="vector-profile",
+                algorithm_configuration_name=algorithm_config.name,
+            )
+        ],
+    )
+
+    # Create the search index
+    index = SearchIndex(
+        name=index_name, fields=index_fields, vector_search=vector_search
+    )
+
+    try:
+        result = index_client.create_or_update_index(index)
+        return {
+            "index_name": result.name,
+            "vector_fields": vector_fields,
+            "vector_dimensions": vector_dimensions,
+            "algorithm": algorithm_kind,
+            "created": True,
+        }
+    except Exception as e:
+        return {"error": str(e), "created": False}

flock/core/tools/basic_tools.py

@@ -1,9 +1,10 @@
 """This module contains basic agentic tools for performing various tasks."""
 
 import importlib
+import json
 import os
 import re
-from typing import Literal
+from typing import Any, Literal
 
 from flock.core.interpreter.python_interpreter import PythonInterpreter
 from flock.core.logging.trace_and_logged import traced_and_logged
@@ -201,8 +202,6 @@ def extract_numbers(text: str) -> list[float]:
 
 @traced_and_logged
 def json_parse_safe(text: str) -> dict:
-    import json
-
     try:
         result = json.loads(text)
         return result
@@ -221,9 +220,98 @@ def save_to_file(content: str, filename: str):
 
 @traced_and_logged
 def read_from_file(filename: str) -> str:
+    with open(filename, encoding="utf-8") as file:
+        return file.read()
+
+
+@traced_and_logged
+def json_search(
+    json_file_path: str, search_query: str, case_sensitive: bool = False
+) -> list:
+    """Search a JSON file for objects containing the specified search query.
+
+    Args:
+        json_file_path (str): Path to the JSON file to search
+        search_query (str): Text to search for within the JSON objects
+        case_sensitive (bool, optional): Whether to perform a case-sensitive search. Defaults to False.
+
+    Returns:
+        list: List of JSON objects (as dicts) that contain the search query
+
+    Example:
+        >>> matching_tickets = json_search("tickets.json", "error 404")
+        >>> print(
+        ...     f"Found {len(matching_tickets)} tickets mentioning '404 error'"
+        ... )
+    """
     try:
-        with open(filename) as f:
-            content = f.read()
-        return content
-    except Exception:
-        raise
+        # Read the JSON file
+        file_content = read_from_file(json_file_path)
+
+        # Parse the JSON content
+        json_data = json_parse_safe(file_content)
+
+        # Convert search query to lowercase if case-insensitive search
+        if not case_sensitive:
+            search_query = search_query.lower()
+
+        results = []
+
+        # Determine if the JSON root is an object or array
+        if isinstance(json_data, dict):
+            # Handle case where root is a dictionary object
+            for key, value in json_data.items():
+                if isinstance(value, list):
+                    # If this key contains a list of objects, search within them
+                    matching_items = _search_in_list(
+                        value, search_query, case_sensitive
+                    )
+                    results.extend(matching_items)
+                elif _contains_text(value, search_query, case_sensitive):
+                    # The entire object matches
+                    results.append(json_data)
+                    break
+        elif isinstance(json_data, list):
+            # Handle case where root is an array
+            matching_items = _search_in_list(
+                json_data, search_query, case_sensitive
+            )
+            results.extend(matching_items)
+
+        return results
+
+    except Exception as e:
+        return [{"error": f"Error searching JSON file: {e!s}"}]
+
+
+def _search_in_list(
+    items: list, search_query: str, case_sensitive: bool
+) -> list:
+    """Helper function to search for text in a list of items."""
+    matching_items = []
+    for item in items:
+        if _contains_text(item, search_query, case_sensitive):
+            matching_items.append(item)
+    return matching_items
+
+
+def _contains_text(obj: Any, search_query: str, case_sensitive: bool) -> bool:
+    """Recursively check if an object contains the search query in any of its string values."""
+    if isinstance(obj, str):
+        # For string values, check if they contain the search query
+        if case_sensitive:
+            return search_query in obj
+        else:
+            return search_query in obj.lower()
+    elif isinstance(obj, dict):
+        # For dictionaries, check each value
+        for value in obj.values():
+            if _contains_text(value, search_query, case_sensitive):
+                return True
+    elif isinstance(obj, list):
+        # For lists, check each item
+        for item in obj:
+            if _contains_text(item, search_query, case_sensitive):
+                return True
+    # For other types (numbers, booleans, None), return False
+    return False

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.16
+Version: 0.3.18
 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: azure-search-documents>=11.5.2
 Requires-Dist: chromadb>=0.6.3
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: devtools>=0.12.2
@@ -29,6 +30,7 @@ Requires-Dist: prometheus-client>=0.21.1
 Requires-Dist: pydantic>=2.10.5
 Requires-Dist: python-box>=7.3.2
 Requires-Dist: python-decouple>=3.8
+Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: sentence-transformers>=3.4.1

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

@@ -8,7 +8,7 @@ flock/cli/load_examples.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 flock/cli/load_flock.py,sha256=3JdECvt5X7uyOG2vZS3-Zk5C5SI_84_QZjcsB3oJmfA,932
 flock/cli/load_release_notes.py,sha256=qFcgUrMddAE_TP6x1P-6ZywTUjTknfhTDW5LTxtg1yk,599
 flock/cli/settings.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
-flock/cli/assets/release_notes.md,sha256=-RuE-G9Sn8z1LWEdr9iqjuQN7N1K_JMaCzHYoyLR42U,4793
+flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/core/__init__.py,sha256=mPlvKc0SxC2qCvSlgYeP_7EyV8ptmdn24NO8mlQoCSo,559
 flock/core/flock.py,sha256=IURlcuNvdsnqKkvgXtX4v_pGWQ8Lfb60X--MT0zvxHo,19881
 flock/core/flock_agent.py,sha256=QPyRSa1X_aAK2MSgqLNHBiL-_cnYHOSSnrFup2YTzss,12509
@@ -40,7 +40,8 @@ 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=P1-RWkw57U2vSxPTCd5awlNg4MME4GkBLEB5HiiKmkw,5715
+flock/core/tools/azure_tools.py,sha256=9Bi6IrB5pzBTBhBSxpCVMgx8HBud8nl4gDp8aN0NT6c,17031
+flock/core/tools/basic_tools.py,sha256=hEG14jNZ2itVvubCHTfsWkuJK6yuNwBtuFj2Js0VHZs,9043
 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
@@ -411,8 +412,8 @@ flock/workflow/activities.py,sha256=yah-lHjMW6_Ww1gt7hMXBis1cJRlcbHx0uLsMB9oNZ0,
 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.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,,
+flock_core-0.3.18.dist-info/METADATA,sha256=NiwExibjtEysHFQNtBSV0KMH36KFkeU6WFh0VEohXe4,20584
+flock_core-0.3.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.18.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.18.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.18.dist-info/RECORD,,