flock-core 0.5.0b7__py3-none-any.whl → 0.5.0b9__py3-none-any.whl

flock/components/evaluation/declarative_evaluation_component.py

@@ -40,6 +40,10 @@ class DeclarativeEvaluationConfig(AgentComponentConfig):
         default=False,
         description="Include the thought process in the output.",
     )
+    include_reasoning: bool = Field(
+        default=False,
+        description="Include the reasoning in the output.",
+    )
     kwargs: dict[str, Any] = Field(default_factory=dict)
 
 
@@ -160,6 +164,9 @@ class DeclarativeEvaluationComponent(
             self._lm_history = lm_history
 
         console.print("\n")
+        result_dict = self.filter_reasoning(
+                    result_dict, self.config.include_reasoning
+                )
         return self.filter_thought_process(
             result_dict, self.config.include_thought_process
         )
@@ -174,6 +181,9 @@ class DeclarativeEvaluationComponent(
             result_dict, cost, lm_history = self._process_result(result_obj, inputs)
             self._cost = cost
             self._lm_history = lm_history
+            result_dict = self.filter_reasoning(
+                    result_dict, self.config.include_reasoning
+                )
             return self.filter_thought_process(
                 result_dict, self.config.include_thought_process
             )
@@ -196,3 +206,17 @@ class DeclarativeEvaluationComponent(
                 for k, v in result_dict.items()
                 if not (k.startswith("reasoning") or k.startswith("trajectory"))
             }
+
+    def filter_reasoning(
+        self, result_dict: dict[str, Any], include_reasoning: bool
+    ) -> dict[str, Any]:
+        """Filter out reasoning from the result dictionary."""
+        if include_reasoning:
+            return result_dict
+        else:
+            return {
+                k: v
+                for k, v in result_dict.items()
+                if not (k.startswith("reasoning"))
+            }
+

flock/core/flock_factory.py

@@ -370,7 +370,7 @@ class FlockFactory:
 
         if not server_config:
             raise ValueError(
-                f"Unable to create server configuration for passed params."
+                "Unable to create server configuration for passed params."
             )
 
         server = concrete_server_cls(config=server_config)
@@ -408,6 +408,7 @@ class FlockFactory:
         write_to_file: bool = False,
         stream: bool = False,
         include_thought_process: bool = False,
+        include_reasoning: bool = False,
         next_agent: DynamicStr | None = None,
         temporal_activity_config: TemporalActivityConfig | None = None,
     ) -> FlockAgent:
@@ -444,6 +445,7 @@ class FlockFactory:
             max_retries=max_retries,
             stream=stream,
             include_thought_process=include_thought_process,
+            include_reasoning=include_reasoning,
         )
         evaluator = DeclarativeEvaluationComponent(
             name="default_evaluator", config=eval_config

flock/webapp/app/api/execution.py

@@ -10,6 +10,7 @@ from fastapi import (  # Ensure Form and HTTPException are imported
     Form,
     Request,
 )
+from fastapi.encoders import jsonable_encoder
 from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 
@@ -151,7 +152,13 @@ async def htmx_run_flock(
             return HTMLResponse(f"<p class='error'>Error processing inputs for {start_agent_name}: {e_parse}</p>")
 
     result_data = await run_current_flock_service(start_agent_name, inputs, request.app.state)
-    raw_json_for_template = json.dumps(result_data, indent=2)
+
+
+    raw_json_for_template = json.dumps(
+        jsonable_encoder(result_data),   # ← converts every nested BaseModel, datetime, etc.
+        indent=2,
+        ensure_ascii=False
+    )
     # Unescape newlines for proper display in HTML <pre> tag
     result_data_raw_json_str = raw_json_for_template.replace('\\n', '\n')
     root_path = request.scope.get("root_path", "")
@@ -215,7 +222,11 @@ async def htmx_run_shared_flock(
 
         shared_logger.info(f"HTMX Run Shared: Executing agent '{start_agent_name}' in pre-loaded Flock '{temp_flock.name}'. Inputs: {list(inputs.keys())}")
         result_data = await temp_flock.run_async(start_agent=start_agent_name, input=inputs, box_result=False)
-        raw_json_for_template = json.dumps(result_data, indent=2)
+        raw_json_for_template = json.dumps(
+            jsonable_encoder(result_data),   # ← converts every nested BaseModel, datetime, etc.
+            indent=2,
+            ensure_ascii=False
+        )
         # Unescape newlines for proper display in HTML <pre> tag
         result_data_raw_json_str = raw_json_for_template.replace('\\n', '\n')
         shared_logger.info(f"HTMX Run Shared: Agent '{start_agent_name}' executed. Result keys: {list(result_data.keys()) if isinstance(result_data, dict) else 'N/A'}")

flock/webapp/app/services/sharing_store.py

@@ -4,6 +4,7 @@ import logging
 import sqlite3
 from abc import ABC, abstractmethod
 from pathlib import Path
+from typing import Any
 
 import aiosqlite
 
@@ -228,135 +229,182 @@ class SQLiteSharedLinkStore(SharedLinkStoreInterface):
             logger.error(f"SQLite error saving feedback {record.feedback_id}: {e}", exc_info=True)
             raise
 
+
+# ---------------------------------------------------------------------------
+# Azure Table + Blob implementation
+# ---------------------------------------------------------------------------
+
+try:
+    from azure.storage.blob.aio import BlobServiceClient
+    AZURE_BLOB_AVAILABLE = True
+except ImportError:  # blob SDK not installed
+    AZURE_BLOB_AVAILABLE = False
+    BlobServiceClient = None
+
 class AzureTableSharedLinkStore(SharedLinkStoreInterface):
-    """Azure Table Storage implementation for storing and retrieving shared link configurations."""
+    """Store configs in Azure Table; store large flock YAML in Blob Storage."""
+
+    _TABLE_NAME        = "flocksharedlinks"
+    _FEEDBACK_TBL_NAME = "flockfeedback"
+    _CONTAINER_NAME    = "flocksharedlinkdefs"          # blobs live here
+    _PARTITION_KEY     = "shared_links"
 
     def __init__(self, connection_string: str):
-        """Initialize Azure Table Storage store with connection string."""
         if not AZURE_AVAILABLE:
-            raise ImportError("Azure Table Storage dependencies not available. Install with: pip install azure-data-tables")
+            raise ImportError("pip install azure-data-tables")
+        if not AZURE_BLOB_AVAILABLE:
+            raise ImportError("pip install azure-storage-blob")
 
         self.connection_string = connection_string
-        self.table_service_client = TableServiceClient.from_connection_string(connection_string)
-        self.shared_links_table_name = "flocksharedlinks"
-        self.feedback_table_name = "flockfeedback"
-        logger.info("AzureTableSharedLinkStore initialized")
+        self.table_svc = TableServiceClient.from_connection_string(connection_string)
+        self.blob_svc  = BlobServiceClient.from_connection_string(connection_string)
 
+    # ------------------------------------------------------------------ init
     async def initialize(self) -> None:
-        """Initializes the Azure Tables (creates them if they don't exist)."""
+        # 1. Azure Tables ----------------------------------------------------
         try:
-            # Create shared_links table
-            try:
-                await self.table_service_client.create_table(self.shared_links_table_name)
-                logger.info(f"Created Azure Table: {self.shared_links_table_name}")
-            except ResourceExistsError:
-                logger.debug(f"Azure Table already exists: {self.shared_links_table_name}")
-
-            # Create feedback table
-            try:
-                await self.table_service_client.create_table(self.feedback_table_name)
-                logger.info(f"Created Azure Table: {self.feedback_table_name}")
-            except ResourceExistsError:
-                logger.debug(f"Azure Table already exists: {self.feedback_table_name}")
-
-            logger.info("Azure Table Storage initialized successfully")
-        except Exception as e:
-            logger.error(f"Error initializing Azure Table Storage: {e}", exc_info=True)
-            raise
+            await self.table_svc.create_table(self._TABLE_NAME)
+            logger.info("Created Azure Table '%s'", self._TABLE_NAME)
+        except ResourceExistsError:
+            logger.debug("Azure Table '%s' already exists", self._TABLE_NAME)
 
-    async def save_config(self, config: SharedLinkConfig) -> SharedLinkConfig:
-        """Saves a shared link configuration to Azure Table Storage."""
         try:
-            table_client = self.table_service_client.get_table_client(self.shared_links_table_name)
-
-            entity = {
-                "PartitionKey": "shared_links",  # Use a fixed partition key for simplicity
-                "RowKey": config.share_id,
-                "share_id": config.share_id,
-                "agent_name": config.agent_name,
-                "flock_definition": config.flock_definition,
-                "created_at": config.created_at.isoformat(),
-                "share_type": config.share_type,
-                "chat_message_key": config.chat_message_key,
-                "chat_history_key": config.chat_history_key,
-                "chat_response_key": config.chat_response_key,
-            }
-
-            await table_client.upsert_entity(entity)
-            logger.info(f"Saved shared link config to Azure Table Storage for ID: {config.share_id} with type: {config.share_type}")
-            return config
-        except Exception as e:
-            logger.error(f"Error saving config to Azure Table Storage for ID {config.share_id}: {e}", exc_info=True)
-            raise
+            await self.table_svc.create_table(self._FEEDBACK_TBL_NAME)
+            logger.info("Created Azure Table '%s'", self._FEEDBACK_TBL_NAME)
+        except ResourceExistsError:
+            logger.debug("Azure Table '%s' already exists", self._FEEDBACK_TBL_NAME)
 
+        # 2. Blob container --------------------------------------------------
+        try:
+            await self.blob_svc.create_container(self._CONTAINER_NAME)
+            logger.info("Created Blob container '%s'", self._CONTAINER_NAME)
+        except ResourceExistsError:
+            logger.debug("Blob container '%s' already exists", self._CONTAINER_NAME)
+
+    # ------------------------------------------------------------- save_config
+    async def save_config(self, config: SharedLinkConfig) -> SharedLinkConfig:
+        """Upload YAML to Blob, then upsert table row containing the blob name."""
+        blob_name   = f"{config.share_id}.yaml"
+        blob_client = self.blob_svc.get_blob_client(self._CONTAINER_NAME, blob_name)
+
+        # 1. Upload flock_definition (overwrite in case of retry)
+        await blob_client.upload_blob(config.flock_definition,
+                                      overwrite=True,
+                                      content_type="text/yaml")
+        logger.debug("Uploaded blob '%s' (%d bytes)",
+                     blob_name, len(config.flock_definition.encode()))
+
+        # 2. Persist lightweight record in the table
+        tbl_client = self.table_svc.get_table_client(self._TABLE_NAME)
+        entity = {
+            "PartitionKey": self._PARTITION_KEY,
+            "RowKey":       config.share_id,
+            "agent_name":   config.agent_name,
+            "created_at":   config.created_at.isoformat(),
+            "share_type":   config.share_type,
+            "chat_message_key":  config.chat_message_key,
+            "chat_history_key":  config.chat_history_key,
+            "chat_response_key": config.chat_response_key,
+            # NEW – just a few bytes, well under 64 KiB
+            "flock_blob_name": blob_name,
+        }
+        await tbl_client.upsert_entity(entity)
+        logger.info("Saved shared link %s → blob '%s'", config.share_id, blob_name)
+        return config
+
+    # -------------------------------------------------------------- get_config
     async def get_config(self, share_id: str) -> SharedLinkConfig | None:
-        """Retrieves a shared link configuration from Azure Table Storage by its ID."""
+        tbl_client = self.table_svc.get_table_client(self._TABLE_NAME)
         try:
-            table_client = self.table_service_client.get_table_client(self.shared_links_table_name)
-
-            entity = await table_client.get_entity(partition_key="shared_links", row_key=share_id)
-
-            logger.debug(f"Retrieved shared link config from Azure Table Storage for ID: {share_id}")
-            return SharedLinkConfig(
-                share_id=entity["share_id"],
-                agent_name=entity["agent_name"],
-                created_at=entity["created_at"],  # Pydantic will parse from ISO format
-                flock_definition=entity["flock_definition"],
-                share_type=entity.get("share_type", "agent_run"),
-                chat_message_key=entity.get("chat_message_key"),
-                chat_history_key=entity.get("chat_history_key"),
-                chat_response_key=entity.get("chat_response_key"),
-            )
+            entity = await tbl_client.get_entity(self._PARTITION_KEY, share_id)
         except ResourceNotFoundError:
-            logger.debug(f"No shared link config found in Azure Table Storage for ID: {share_id}")
+            logger.debug("No config entity for id '%s'", share_id)
             return None
+
+        blob_name   = entity["flock_blob_name"]
+        blob_client = self.blob_svc.get_blob_client(self._CONTAINER_NAME, blob_name)
+        try:
+            blob_bytes = await (await blob_client.download_blob()).readall()
+            flock_yaml = blob_bytes.decode()
         except Exception as e:
-            logger.error(f"Error retrieving config from Azure Table Storage for ID {share_id}: {e}", exc_info=True)
-            return None
+            logger.error("Cannot download blob '%s' for share_id=%s: %s",
+                         blob_name, share_id, e, exc_info=True)
+            raise
 
+        return SharedLinkConfig(
+            share_id          = share_id,
+            agent_name        = entity["agent_name"],
+            created_at        = entity["created_at"],
+            flock_definition  = flock_yaml,
+            share_type        = entity.get("share_type", "agent_run"),
+            chat_message_key  = entity.get("chat_message_key"),
+            chat_history_key  = entity.get("chat_history_key"),
+            chat_response_key = entity.get("chat_response_key"),
+        )
+
+    # ----------------------------------------------------------- delete_config
     async def delete_config(self, share_id: str) -> bool:
-        """Deletes a shared link configuration from Azure Table Storage by its ID."""
+        tbl_client = self.table_svc.get_table_client(self._TABLE_NAME)
         try:
-            table_client = self.table_service_client.get_table_client(self.shared_links_table_name)
-
-            await table_client.delete_entity(partition_key="shared_links", row_key=share_id)
-            logger.info(f"Deleted shared link config from Azure Table Storage for ID: {share_id}")
-            return True
+            entity = await tbl_client.get_entity(self._PARTITION_KEY, share_id)
         except ResourceNotFoundError:
-            logger.info(f"Attempted to delete non-existent shared link config from Azure Table Storage for ID: {share_id}")
-            return False
-        except Exception as e:
-            logger.error(f"Error deleting config from Azure Table Storage for ID {share_id}: {e}", exc_info=True)
+            logger.info("Delete: entity %s not found", share_id)
             return False
 
-    # ----------------------- Feedback methods -----------------------
+        # 1. Remove blob (ignore missing blob)
+        blob_name   = entity["flock_blob_name"]
+        blob_client = self.blob_svc.get_blob_client(self._CONTAINER_NAME, blob_name)
+        try:
+            await blob_client.delete_blob(delete_snapshots="include")
+            logger.debug("Deleted blob '%s'", blob_name)
+        except ResourceNotFoundError:
+            logger.warning("Blob '%s' already gone", blob_name)
+
+        # 2. Remove table row
+        await tbl_client.delete_entity(self._PARTITION_KEY, share_id)
+        logger.info("Deleted shared link %s and its blob", share_id)
+        return True
 
+    # -------------------------------------------------------- save_feedback --
     async def save_feedback(self, record: FeedbackRecord) -> FeedbackRecord:
-        """Persist a feedback record to Azure Table Storage."""
-        try:
-            table_client = self.table_service_client.get_table_client(self.feedback_table_name)
-
-            entity = {
-                "PartitionKey": "feedback",  # Use a fixed partition key for simplicity
-                "RowKey": record.feedback_id,
-                "feedback_id": record.feedback_id,
-                "share_id": record.share_id,
-                "context_type": record.context_type,
-                "reason": record.reason,
-                "expected_response": record.expected_response,
-                "actual_response": record.actual_response,
-                "flock_name": record.flock_name,
-                "agent_name": record.agent_name,
-                "flock_definition": record.flock_definition,
-                "created_at": record.created_at.isoformat(),
-            }
-
-            await table_client.upsert_entity(entity)
-            logger.info(f"Saved feedback to Azure Table Storage: {record.feedback_id} (share={record.share_id})")
-            return record
-        except Exception as e:
-            logger.error(f"Error saving feedback to Azure Table Storage {record.feedback_id}: {e}", exc_info=True)
-            raise
+        """Persist a feedback record. If a flock_definition is present, upload it as a blob and
+        store only a reference in the table row to avoid oversized entities (64 KiB limit).
+        """
+        tbl_client = self.table_svc.get_table_client(self._FEEDBACK_TBL_NAME)
+
+        # Core entity fields (avoid dumping the full Pydantic model – too many columns / large value)
+        entity: dict[str, Any] = {
+            "PartitionKey": "feedback",
+            "RowKey":       record.feedback_id,
+            "share_id":     record.share_id,
+            "context_type": record.context_type,
+            "reason":       record.reason,
+            "expected_response": record.expected_response,
+            "actual_response":   record.actual_response,
+            "created_at":   record.created_at.isoformat(),
+        }
+        if record.flock_name is not None:
+            entity["flock_name"] = record.flock_name
+        if record.agent_name is not None:
+            entity["agent_name"] = record.agent_name
+
+        # ------------------------------------------------------------------ YAML → Blob
+        if record.flock_definition:
+            blob_name   = f"{record.feedback_id}.yaml"
+            blob_client = self.blob_svc.get_blob_client(self._CONTAINER_NAME, blob_name)
+            # Overwrite=true so repeated feedback_id uploads (shouldn't happen) won't error
+            await blob_client.upload_blob(record.flock_definition,
+                                          overwrite=True,
+                                          content_type="text/yaml")
+            entity["flock_blob_name"] = blob_name  # lightweight reference only
+
+        # ------------------------------------------------------------------ Table upsert
+        await tbl_client.upsert_entity(entity)
+        logger.info("Saved feedback %s%s",
+                    record.feedback_id,
+                    f" → blob '{entity['flock_blob_name']}'" if "flock_blob_name" in entity else "")
+        return record
+
 
 
 # ----------------------- Factory Function -----------------------