flock-core 0.4.511__tar.gz → 0.4.512__tar.gz

{flock_core-0.4.511 → flock_core-0.4.512}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.511
+Version: 0.4.512
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -9,7 +9,9 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: aiosqlite>=0.21.0
+Requires-Dist: azure-data-tables>=12.7.0
 Requires-Dist: cloudpickle>=3.1.1
+Requires-Dist: croniter>=6.0.0
 Requires-Dist: devtools>=0.12.2
 Requires-Dist: dspy==2.6.23
 Requires-Dist: fastapi>=0.115.8

{flock_core-0.4.511 → flock_core-0.4.512}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.511"
+version = "0.4.512"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [
@@ -52,6 +52,8 @@ dependencies = [
     "wd-di>=0.2.14",
     "websockets>=15.0.1",
     "opik>=1.7.26",
+    "azure-data-tables>=12.7.0",
+    "croniter>=6.0.0",
 ]
 
 [project.optional-dependencies]

flock_core-0.4.512/src/flock/core/config/flock_agent_config.py

@@ -0,0 +1,11 @@
+
+
+from pydantic import BaseModel
+
+
+class FlockAgentConfig(BaseModel):
+    """FlockAgentConfig is a class that holds the configuration for a Flock agent.
+    It is used to store various settings and parameters that can be accessed throughout the agent's lifecycle.
+    """
+
+    pass

flock_core-0.4.512/src/flock/core/config/scheduled_agent_config.py

@@ -0,0 +1,40 @@
+
+
+
+from pydantic import Field
+
+from flock.core.config.flock_agent_config import FlockAgentConfig
+
+
+class ScheduledAgentConfig(FlockAgentConfig):
+    """Configuration specific to agents that run on a schedule."""
+    schedule_expression: str = Field(
+        ...,
+        description="Defines when the agent should run. "
+                    "Examples: 'every 60m', 'every 1h', 'daily at 02:00', '0 */2 * * *' (cron expression)"
+    )
+    enabled: bool = Field(
+        True,
+        description="Whether the scheduled agent is enabled. "
+                    "If False, the agent will not run even if the schedule expression is valid."
+    )
+    initial_run: bool = Field(
+        False,
+        description="If True, the agent will run immediately after being scheduled, "
+                    "regardless of the schedule expression."
+    )
+    max_runs: int = Field(
+        0,
+        description="Maximum number of times the agent can run. "
+                    "0 means unlimited runs. If set, the agent will stop running after reaching this limit."
+    )
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Ensure schedule_expression is always set
+        if 'schedule_expression' not in kwargs:
+            raise ValueError("schedule_expression is required for ScheduledAgentConfig")
+
+        # Validate initial_run and max_runs
+        if self.initial_run and self.max_runs > 0:
+            raise ValueError("Cannot set initial_run to True if max_runs is greater than 0")

{flock_core-0.4.511 → flock_core-0.4.512}/src/flock/core/flock_agent.py

@@ -10,6 +10,7 @@ from collections.abc import Callable
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, TypeVar
 
+from flock.core.config.flock_agent_config import FlockAgentConfig
 from flock.core.mcp.flock_mcp_server import FlockMCPServerBase
 from flock.core.serialization.json_encoder import FlockJSONEncoder
 from flock.workflow.temporal_config import TemporalActivityConfig
@@ -124,6 +125,11 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         description="Dictionary of FlockModules attached to this agent.",
     )
 
+    config: FlockAgentConfig = Field(
+        default_factory=lambda: FlockAgentConfig(),
+        description="Configuration for this agent, holding various settings and parameters.",
+    )
+
     # --- Temporal Configuration (Optional) ---
     temporal_activity_config: TemporalActivityConfig | None = Field(
         default=None,

{flock_core-0.4.511 → flock_core-0.4.512}/src/flock/core/flock_factory.py

@@ -7,6 +7,7 @@ from typing import Any, Literal
 
 from pydantic import AnyUrl, BaseModel, Field, FileUrl
 
+from flock.core.config.scheduled_agent_config import ScheduledAgentConfig
 from flock.core.flock_agent import FlockAgent, SignatureType
 from flock.core.logging.formatters.themes import OutputTheme
 from flock.core.mcp.flock_mcp_server import FlockMCPServerBase
@@ -381,3 +382,46 @@ class FlockFactory:
         agent.add_module(output_module)
         agent.add_module(metrics_module)
         return agent
+
+    @staticmethod
+    def create_scheduled_agent(
+        name: str,
+        schedule_expression: str, # e.g., "every 1h", "0 0 * * *"
+        description: str | Callable[..., str] | None = None,
+        model: str | Callable[..., str] | None = None,
+        input: SignatureType = None, # Input might be implicit or none
+        output: SignatureType = None, # Input might be implicit or none
+        tools: list[Callable[..., Any] | Any] | None = None,
+        servers: list[str | FlockMCPServerBase] | None = None,
+        use_cache: bool = False, # Whether to cache results
+        temperature: float = 0.7, # Temperature for model responses
+        # ... other common agent params from create_default_agent ...
+        temporal_activity_config: TemporalActivityConfig | None = None, # If you want scheduled tasks to be Temporal activities
+        **kwargs # Forward other standard agent params
+    ) -> FlockAgent:
+        """Creates a FlockAgent configured to run on a schedule."""
+        agent_config = ScheduledAgentConfig( # Use the new config type
+            schedule_expression=schedule_expression,
+            enabled=True,
+            initial_run=True,
+            max_runs=0,
+            **kwargs
+        )
+
+
+        agent = FlockFactory.create_default_agent( # Reuse your existing factory
+            name=name,
+            description=description,
+            model=model,
+            input=input + ", trigger_time: str | Time of scheduled execution",
+            output=output,
+            tools=tools,
+            servers=servers,
+            temporal_activity_config=temporal_activity_config,
+            use_cache=use_cache,
+            temperature=temperature,
+            **kwargs
+        )
+        agent.config = agent_config  # Assign the scheduled agent config
+
+        return agent

flock_core-0.4.512/src/flock/core/flock_scheduler.py

@@ -0,0 +1,166 @@
+# src/flock/core/scheduler.py (new file or inside flock.py)
+import asyncio
+import traceback
+from datetime import datetime, timedelta, timezone
+
+from croniter import croniter  # pip install croniter
+
+from flock.core.flock import Flock
+from flock.core.flock_agent import FlockAgent  # For type hinting
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("flock.scheduler")
+
+class FlockScheduler:
+    def __init__(self, flock_instance: Flock):
+        self.flock = flock_instance
+        self._scheduled_tasks: list[tuple[FlockAgent, croniter | timedelta, datetime | None]] = []
+        self._stop_event = asyncio.Event()
+        self._is_running = False
+
+    def _parse_schedule_expression(self, expression: str) -> croniter | timedelta:
+        """Parses a schedule expression.
+        Supports cron syntax and simple intervals like 'every Xm', 'every Xh', 'every Xd'.
+        """
+        expression = expression.strip().lower()
+        if expression.startswith("every "):
+            try:
+                parts = expression.split(" ")
+                value = int(parts[1][:-1])
+                unit = parts[1][-1]
+                if unit == 's': return timedelta(seconds=value)
+                if unit == 'm': return timedelta(minutes=value)
+                elif unit == 'h': return timedelta(hours=value)
+                elif unit == 'd': return timedelta(days=value)
+                else: raise ValueError(f"Invalid time unit: {unit}")
+            except Exception as e:
+                logger.error(f"Invalid interval expression '{expression}': {e}")
+                raise ValueError(f"Invalid interval expression: {expression}") from e
+        else:
+            # Assume cron expression
+            if not croniter.is_valid(expression):
+                raise ValueError(f"Invalid cron expression: {expression}")
+            return croniter(expression, datetime.now(timezone.utc))
+
+    def add_agent(self, agent: FlockAgent):
+        """Adds an agent to the scheduler if it has a schedule expression."""
+        # Assuming schedule_expression is stored in agent._flock_config or a dedicated field
+        schedule_expression = None
+        if hasattr(agent, '_flock_config') and isinstance(agent._flock_config, dict):
+            schedule_expression = agent._flock_config.get('schedule_expression')
+        elif hasattr(agent, 'schedule_expression'): # If directly on agent
+             schedule_expression = agent.schedule_expression
+        elif hasattr(agent, 'config') and hasattr(agent.config, 'schedule_expression'): # If on agent.config
+            schedule_expression = agent.config.schedule_expression
+
+
+        if not schedule_expression:
+            logger.warning(f"Agent '{agent.name}' has no schedule_expression. Skipping.")
+            return
+
+        try:
+            parsed_schedule = self._parse_schedule_expression(schedule_expression)
+            self._scheduled_tasks.append((agent, parsed_schedule, None)) # agent, schedule, last_run_utc
+            logger.info(f"Scheduled agent '{agent.name}' with expression: {schedule_expression}")
+        except ValueError as e:
+            logger.error(f"Could not schedule agent '{agent.name}': {e}")
+
+    def _load_scheduled_agents_from_flock(self):
+        """Scans the Flock instance for agents with scheduling configuration."""
+        self._scheduled_tasks = [] # Clear existing before loading
+        for agent_name, agent_instance in self.flock.agents.items():
+            self.add_agent(agent_instance)
+        logger.info(f"Loaded {len(self._scheduled_tasks)} scheduled agents from Flock '{self.flock.name}'.")
+
+    async def _run_agent_task(self, agent: FlockAgent, trigger_time: datetime):
+        logger.info(f"Triggering scheduled agent '{agent.name}' at {trigger_time.isoformat()}")
+        try:
+            # Input for a scheduled agent could include the trigger time
+            await self.flock.run_async(start_agent=agent.name, input={"trigger_time": trigger_time})
+            logger.info(f"Scheduled agent '{agent.name}' finished successfully.")
+        except Exception as e:
+            logger.error(f"Error running scheduled agent '{agent.name}': {e}\n{traceback.format_exc()}")
+
+    async def _scheduler_loop(self):
+        self._is_running = True
+        logger.info("FlockScheduler loop started.")
+        while not self._stop_event.is_set():
+            now_utc = datetime.now(timezone.utc)
+            tasks_to_run_this_cycle = []
+
+            for i, (agent, schedule, last_run_utc) in enumerate(self._scheduled_tasks):
+                should_run = False
+                next_run_utc = None
+
+                if isinstance(schedule, croniter):
+                    # For cron, get the next scheduled time AFTER the last run (or now if never run)
+                    base_time = last_run_utc if last_run_utc else now_utc
+                    # Croniter's get_next gives the next time *after* the base_time.
+                    # If last_run_utc is None (first run), we check if the *current* now_utc
+                    # is past the first scheduled time.
+                    # A simpler check: is `now_utc` >= `schedule.get_next(datetime, base_time=last_run_utc if last_run_utc else now_utc - timedelta(seconds=1))` ?
+                    # Let's refine croniter check to be more precise.
+                    # If we are past the *next* scheduled time since *last check*
+                    if last_run_utc is None: # First run check
+                        next_run_utc = schedule.get_next(datetime, start_time=now_utc - timedelta(seconds=1)) # Check if first run is due
+                        if next_run_utc <= now_utc:
+                            should_run = True
+                    else:
+                        next_run_utc = schedule.get_next(datetime, start_time=last_run_utc)
+                        if next_run_utc <= now_utc:
+                            should_run = True
+
+                elif isinstance(schedule, timedelta): # Simple interval
+                    if last_run_utc is None or (now_utc - last_run_utc >= schedule):
+                        should_run = True
+                        next_run_utc = now_utc # Or now_utc + schedule for next interval start
+                    else:
+                        next_run_utc = last_run_utc + schedule
+
+
+                if should_run:
+                    tasks_to_run_this_cycle.append(self._run_agent_task(agent, now_utc))
+                    # Update last_run_utc for this agent *before* awaiting its execution
+                    # For cron, advance the iterator to the *current* scheduled time that triggered it.
+                    if isinstance(schedule, croniter):
+                         current_cron_trigger = schedule.get_current(datetime) # This is the time it *should* have run
+                         self._scheduled_tasks[i] = (agent, schedule, current_cron_trigger)
+
+                    elif isinstance(schedule, timedelta):
+                        self._scheduled_tasks[i] = (agent, schedule, now_utc) # Mark as run now
+
+            if tasks_to_run_this_cycle:
+                await asyncio.gather(*tasks_to_run_this_cycle, return_exceptions=True)
+
+            try:
+                # Sleep for a short interval, e.g., 10 seconds, or until stop_event is set
+                await asyncio.wait_for(self._stop_event.wait(), timeout=10.0)
+            except asyncio.TimeoutError:
+                pass # Timeout is normal, means continue loop
+        self._is_running = False
+        logger.info("FlockScheduler loop stopped.")
+
+    async def start(self) -> asyncio.Task | None: # Modified to return Task or None
+        if self._is_running:
+            logger.warning("Scheduler is already running.")
+            return None # Or return the existing task if you store it
+
+        self._load_scheduled_agents_from_flock()
+        if not self._scheduled_tasks:
+            logger.info("No scheduled agents found. Scheduler will not start a loop task.")
+            return None # Return None if no tasks to schedule
+
+        self._stop_event.clear()
+        loop_task = asyncio.create_task(self._scheduler_loop())
+        # Store the task if you need to reference it, e.g., for forced cancellation beyond _stop_event
+        # self._loop_task = loop_task
+        return loop_task # Return the created task
+
+    async def stop(self):
+        if not self._is_running and not self._stop_event.is_set(): # Check if stop already called
+            logger.info("Scheduler is not running or already signaled to stop.")
+            return
+        logger.info("Stopping FlockScheduler...")
+        self._stop_event.set()
+        # If you stored self._loop_task, you can await it here or in the lifespan manager
+        # await self._loop_task # (This might block if loop doesn't exit quickly)

{flock_core-0.4.511 → flock_core-0.4.512}/src/flock/webapp/app/main.py

@@ -1,4 +1,5 @@
 # src/flock/webapp/app/main.py
+import asyncio
 import json
 import os  # Added import
 import shutil
@@ -8,6 +9,7 @@ import urllib.parse
 import uuid
 from contextlib import asynccontextmanager
 from pathlib import Path
+from typing import Any
 
 import markdown2  # Import markdown2
 from fastapi import (
@@ -24,13 +26,13 @@ from fastapi.responses import HTMLResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from pydantic import BaseModel
-from typing import Any
 
 from flock.core.api.endpoints import create_api_router
 from flock.core.api.run_store import RunStore
 
 # Import core Flock components and API related modules
 from flock.core.flock import Flock  # For type hinting
+from flock.core.flock_scheduler import FlockScheduler
 from flock.core.logging.logging import get_logger  # For logging
 from flock.core.util.spliter import parse_schema
 
@@ -44,7 +46,6 @@ from flock.webapp.app.api import (
 from flock.webapp.app.config import (
     DEFAULT_THEME_NAME,
     FLOCK_FILES_DIR,
-    SHARED_LINKS_DB_PATH,
     THEMES_DIR,
     get_current_theme_name,
 )
@@ -72,7 +73,7 @@ from flock.webapp.app.services.flock_service import (
 from flock.webapp.app.services.sharing_models import SharedLinkConfig
 from flock.webapp.app.services.sharing_store import (
     SharedLinkStoreInterface,
-    SQLiteSharedLinkStore,
+    create_shared_link_store,
 )
 from flock.webapp.app.theme_mapper import alacritty_to_pico
 
@@ -138,23 +139,21 @@ async def lifespan(app: FastAPI):
     logger.info("FastAPI application starting up...")
     # Flock instance and RunStore are expected to be set on app.state
     # by `start_unified_server` in `webapp/run.py` *before* uvicorn starts the app.
-    # The call to `set_global_flock_services` also happens there.
-
-    # Initialize and set the SharedLinkStore
+    # The call to `set_global_flock_services` also happens there.    # Initialize and set the SharedLinkStore
     try:
-        logger.info(f"Initializing SharedLinkStore with DB path: {SHARED_LINKS_DB_PATH}")
-        shared_link_store = SQLiteSharedLinkStore(db_path=str(SHARED_LINKS_DB_PATH))
+        logger.info("Initializing SharedLinkStore using factory...")
+        shared_link_store = create_shared_link_store()
         await shared_link_store.initialize() # Create tables if they don't exist
         set_global_shared_link_store(shared_link_store)
         logger.info("SharedLinkStore initialized and set globally.")
     except Exception as e:
-        logger.error(f"Failed to initialize SharedLinkStore: {e}", exc_info=True)    # Configure chat features with clear precedence:
+        logger.error(f"Failed to initialize SharedLinkStore: {e}", exc_info=True)# Configure chat features with clear precedence:
     # 1. Value set by start_unified_server (programmatic)
     # 2. Environment variables (standalone mode)
     programmatic_chat_enabled = getattr(app.state, "chat_enabled", None)
     env_start_mode = os.environ.get("FLOCK_START_MODE")
     env_chat_enabled = os.environ.get("FLOCK_CHAT_ENABLED", "false").lower() == "true"
-    
+
     if programmatic_chat_enabled is not None:
         # Programmatic setting takes precedence (from start_unified_server)
         should_enable_chat_routes = programmatic_chat_enabled
@@ -235,11 +234,66 @@ async def lifespan(app: FastAPI):
             logger.info(f"Lifespan: Added {len(pending_endpoints)} custom API routes to main app.")
         else:
             logger.warning("Lifespan: Pending custom endpoints found, but no Flock instance in app.state. Cannot add custom routes.")
+
+    # --- Add Scheduler Startup Logic ---
+    flock_instance_from_state: Flock | None = getattr(app.state, "flock_instance", None)
+    if flock_instance_from_state:
+        # Create and start the scheduler
+        scheduler = FlockScheduler(flock_instance_from_state)
+        app.state.flock_scheduler = scheduler  # Store for access during shutdown
+
+        scheduler_loop_task = await scheduler.start() # Start returns the task
+        if scheduler_loop_task:
+            app.state.flock_scheduler_task = scheduler_loop_task # Store the task
+            logger.info("FlockScheduler background task started.")
+        else:
+            app.state.flock_scheduler_task = None
+            logger.info("FlockScheduler initialized, but no scheduled agents found or loop not started.")
+    else:
+        app.state.flock_scheduler = None
+        app.state.flock_scheduler_task = None
+        logger.warning("No Flock instance found in app.state; FlockScheduler not started.")
+    # --- End Scheduler Startup Logic ---
+
     yield
     logger.info("FastAPI application shutting down...")
 
-app = FastAPI(title="Flock Web UI & API", lifespan=lifespan)
+     # --- Add Scheduler Shutdown Logic ---
+    logger.info("FastAPI application initiating shutdown...")
+    scheduler_to_stop: FlockScheduler | None = getattr(app.state, "flock_scheduler", None)
+    scheduler_task_to_await: asyncio.Task | None = getattr(app.state, "flock_scheduler_task", None)
 
+    if scheduler_to_stop:
+        logger.info("Attempting to stop FlockScheduler...")
+        await scheduler_to_stop.stop() # Signal the scheduler loop to stop
+
+        if scheduler_task_to_await and not scheduler_task_to_await.done():
+            logger.info("Waiting for FlockScheduler task to complete...")
+            try:
+                await asyncio.wait_for(scheduler_task_to_await, timeout=10.0) # Wait for graceful exit
+                logger.info("FlockScheduler task completed gracefully.")
+            except asyncio.TimeoutError:
+                logger.warning("FlockScheduler task did not complete in time, cancelling.")
+                scheduler_task_to_await.cancel()
+                try:
+                    await scheduler_task_to_await # Await cancellation
+                except asyncio.CancelledError:
+                    logger.info("FlockScheduler task cancelled.")
+            except Exception as e:
+                logger.error(f"Error during FlockScheduler task finalization: {e}", exc_info=True)
+        elif scheduler_task_to_await and scheduler_task_to_await.done():
+            logger.info("FlockScheduler task was already done.")
+        else:
+            logger.info("FlockScheduler instance found, but no running task was stored to await.")
+    else:
+        logger.info("No active FlockScheduler found to stop.")
+
+    logger.info("FastAPI application finished shutdown sequence.")
+    # --- End Scheduler Shutdown Logic ---
+
+app = FastAPI(title="Flock Web UI & API", lifespan=lifespan, docs_url="/docs",
+    openapi_url="/openapi.json", root_path=os.getenv("FLOCK_ROOT_PATH", ""))
+logger.info("FastAPI booting complete.")
 BASE_DIR = Path(__file__).resolve().parent.parent
 app.mount("/static", StaticFiles(directory=str(BASE_DIR / "static")), name="static")
 templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
@@ -826,6 +880,7 @@ async def ui_create_flock_action(request: Request, flock_name: str = Form(...),
     context = get_base_context_web(request, success=success_msg_text, ui_mode=ui_mode_query)
     return templates.TemplateResponse("partials/_execution_view_container.html", context, headers=response_headers)
 
+
 # --- Settings Page & Endpoints ---
 @app.get("/ui/settings", response_class=HTMLResponse, tags=["UI Pages"])
 async def page_settings(request: Request, error: str = None, success: str = None, ui_mode: str = Query("standalone")):

{flock_core-0.4.511 → flock_core-0.4.512}/src/flock/webapp/app/services/sharing_store.py

@@ -1,3 +1,5 @@
+"""Shared link and feedback storage implementations supporting SQLite and Azure Table Storage."""
+
 import logging
 import sqlite3
 from abc import ABC, abstractmethod
@@ -10,6 +12,17 @@ from flock.webapp.app.services.sharing_models import (
     SharedLinkConfig,
 )
 
+# Azure Table Storage imports - will be conditionally imported
+try:
+    from azure.core.exceptions import ResourceExistsError, ResourceNotFoundError
+    from azure.data.tables.aio import TableServiceClient
+    AZURE_AVAILABLE = True
+except ImportError:
+    AZURE_AVAILABLE = False
+    TableServiceClient = None
+    ResourceNotFoundError = None
+    ResourceExistsError = None
+
 # Get a logger instance
 logger = logging.getLogger(__name__)
 
@@ -46,6 +59,7 @@ class SQLiteSharedLinkStore(SharedLinkStoreInterface):
     """SQLite implementation for storing and retrieving shared link configurations."""
 
     def __init__(self, db_path: str):
+        """Initialize SQLite store with database path."""
         self.db_path = Path(db_path)
         self.db_path.parent.mkdir(parents=True, exist_ok=True) # Ensure directory exists
         logger.info(f"SQLiteSharedLinkStore initialized with db_path: {self.db_path}")
@@ -213,3 +227,162 @@ class SQLiteSharedLinkStore(SharedLinkStoreInterface):
         except sqlite3.Error as e:
             logger.error(f"SQLite error saving feedback {record.feedback_id}: {e}", exc_info=True)
             raise
+
+class AzureTableSharedLinkStore(SharedLinkStoreInterface):
+    """Azure Table Storage implementation for storing and retrieving shared link configurations."""
+
+    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")
+
+        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")
+
+    async def initialize(self) -> None:
+        """Initializes the Azure Tables (creates them if they don't exist)."""
+        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
+
+    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
+
+    async def get_config(self, share_id: str) -> SharedLinkConfig | None:
+        """Retrieves a shared link configuration from Azure Table Storage by its ID."""
+        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"),
+            )
+        except ResourceNotFoundError:
+            logger.debug(f"No shared link config found in Azure Table Storage for ID: {share_id}")
+            return None
+        except Exception as e:
+            logger.error(f"Error retrieving config from Azure Table Storage for ID {share_id}: {e}", exc_info=True)
+            return None
+
+    async def delete_config(self, share_id: str) -> bool:
+        """Deletes a shared link configuration from Azure Table Storage by its ID."""
+        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
+        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)
+            return False
+
+    # ----------------------- Feedback methods -----------------------
+
+    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
+
+
+# ----------------------- Factory Function -----------------------
+
+def create_shared_link_store(store_type: str | None = None, connection_string: str | None = None) -> SharedLinkStoreInterface:
+    """Factory function to create the appropriate shared link store based on configuration.
+    
+    Args:
+        store_type: Type of store to create ("local" for SQLite, "azure-storage" for Azure Table Storage)
+        connection_string: Connection string for the store (file path for SQLite, connection string for Azure)
+    
+    Returns:
+        Configured SharedLinkStoreInterface implementation
+    """
+    import os
+
+    # Get values from environment if not provided
+    if store_type is None:
+        store_type = os.getenv("FLOCK_WEBAPP_STORE", "local").lower()
+
+    if connection_string is None:
+        connection_string = os.getenv("FLOCK_WEBAPP_STORE_CONNECTION", ".flock/shared_links.db")
+
+    if store_type == "local":
+        return SQLiteSharedLinkStore(connection_string)
+    elif store_type == "azure-storage":
+        return AzureTableSharedLinkStore(connection_string)
+    else:
+        raise ValueError(f"Unsupported store type: {store_type}. Supported types: 'local', 'azure-storage'")