flock-core 0.4.0b49__py3-none-any.whl → 0.4.1__py3-none-any.whl

flock/webapp/app/api/execution.py

@@ -3,6 +3,7 @@ import json
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+import markdown2  # Import markdown2
 from fastapi import (  # Ensure Form and HTTPException are imported
     APIRouter,
     Depends,
@@ -16,9 +17,6 @@ if TYPE_CHECKING:
     from flock.core.flock import Flock
 
 
-from flock.core.flock import (
-    Flock as ConcreteFlock,  # For creating Flock instance
-)
 from flock.core.logging.logging import (
     get_logger as get_flock_logger,  # For logging within the new endpoint
 )
@@ -28,6 +26,7 @@ from flock.core.util.spliter import parse_schema
 from flock.webapp.app.dependencies import (
     get_flock_instance,
     get_optional_flock_instance,
+    get_shared_link_store,
 )
 
 # Service function now takes app_state
@@ -35,12 +34,18 @@ from flock.webapp.app.services.flock_service import (
     run_current_flock_service,
     # get_current_flock_instance IS NO LONGER IMPORTED
 )
-from flock.webapp.app.utils import pydantic_to_dict
+from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
 
 router = APIRouter()
 BASE_DIR = Path(__file__).resolve().parent.parent.parent
 templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
 
+# Add markdown2 filter to Jinja2 environment for this router
+def markdown_filter(text):
+    return markdown2.markdown(text, extras=["tables", "fenced-code-blocks"])
+
+templates.env.filters['markdown'] = markdown_filter
+
 
 @router.get("/htmx/execution-form-content", response_class=HTMLResponse)
 async def htmx_get_execution_form_content(
@@ -102,14 +107,9 @@ async def htmx_get_agent_input_form(
 @router.post("/htmx/run", response_class=HTMLResponse)
 async def htmx_run_flock(
     request: Request,
-    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
 ):
-    # The service function run_current_flock_service now takes app_state
-    # We retrieve current_flock from app_state inside the service or before calling if needed for validation here
-
-    # It's better to get flock from app_state here to validate before calling service
     current_flock_from_state: Flock | None = getattr(request.app.state, 'flock_instance', None)
-    logger = get_flock_logger("webapp.execution.regular_run") # Standard logger
+    logger = get_flock_logger("webapp.execution.regular_run")
 
     if not current_flock_from_state:
         logger.error("HTMX Run (Regular): No Flock loaded in app_state.")
@@ -150,30 +150,23 @@ async def htmx_run_flock(
             logger.error(f"HTMX Run (Regular): Error processing inputs for '{start_agent_name}': {e_parse}", exc_info=True)
             return HTMLResponse(f"<p class='error'>Error processing inputs for {start_agent_name}: {e_parse}</p>")
 
-    try:
-        logger.info(f"HTMX Run (Regular): Executing agent '{start_agent_name}' from Flock '{current_flock_from_state.name}' via service.")
-        result_data = await run_current_flock_service(start_agent_name, inputs, request.app.state)
-    except Exception as e_run:
-        logger.error(f"HTMX Run (Regular): Error during service execution for '{start_agent_name}': {e_run}", exc_info=True)
-        return templates.TemplateResponse(
-            "partials/_results_display.html",
-            {"request": request, "result_data": {"error": f"Error during execution: {e_run!s}"}},
-        )
-
-    # Process and serialize result for template
-    try:
-        processed_result = pydantic_to_dict(result_data)
-        try: json.dumps(processed_result)
-        except (TypeError, ValueError) as ser_e:
-            processed_result = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result preview: {str(result_data)[:500]}..."
-            logger.warning(f"HTMX Run (Regular): Serialization issue: {processed_result}")
-    except Exception as proc_e:
-        processed_result = f"Error: Failed to process result data: {proc_e!s}"
-        logger.error(f"HTMX Run (Regular): Result processing error: {processed_result}", exc_info=True)
+    result_data = await run_current_flock_service(start_agent_name, inputs, request.app.state)
+    raw_json_for_template = json.dumps(result_data, indent=2)
+    # Unescape newlines for proper display in HTML <pre> tag
+    result_data_raw_json_str = raw_json_for_template.replace('\\n', '\n')
 
     return templates.TemplateResponse(
         "partials/_results_display.html",
-        {"request": request, "result_data": processed_result},
+        {
+            "request": request,
+            "result": result_data,
+            "result_raw_json": result_data_raw_json_str,
+            "feedback_endpoint": "/ui/api/flock/htmx/feedback",
+            "share_id": None,
+            "flock_name": current_flock_from_state.name,
+            "agent_name": start_agent_name,
+            "flock_definition": current_flock_from_state.to_yaml(),
+        }
     )
 
 
@@ -181,27 +174,18 @@ async def htmx_run_flock(
 @router.post("/htmx/run-shared", response_class=HTMLResponse)
 async def htmx_run_shared_flock(
     request: Request,
-    share_id: str = Form(...), # Expect share_id from the form
-    # flock_definition_str: str = Form(...), # No longer needed
-    # start_agent_name from form is still required implicitly via form_data.get()
-    # No DI for current_flock, as we are using the one from app.state via share_id
+    share_id: str = Form(...),
 ):
     shared_logger = get_flock_logger("webapp.execution.shared_run_stateful")
     form_data = await request.form()
     start_agent_name = form_data.get("start_agent_name")
 
     if not start_agent_name:
-        shared_logger.warning("HTMX Run Shared (Stateful): Starting agent name not provided in form.")
-        return HTMLResponse("<p class='error'>Critical error: Starting agent name missing from shared run form.</p>")
-
-    shared_logger.info(f"HTMX Run Shared (Stateful): Attempting to execute agent '{start_agent_name}' using pre-loaded Flock for share_id '{share_id}'.")
-
-    inputs = {}
-    result_data: Any = None
-    temp_flock: ConcreteFlock | None = None
+        shared_logger.warning("HTMX Run Shared: Starting agent not selected.")
+        return HTMLResponse("<p class='error'>Starting agent not selected for shared run.</p>")
 
+    inputs: dict[str, Any] = {}
     try:
-        # Retrieve the pre-loaded Flock instance from app.state
         shared_flocks_store = getattr(request.app.state, 'shared_flocks', {})
         temp_flock = shared_flocks_store.get(share_id)
 
@@ -216,14 +200,11 @@ async def htmx_run_shared_flock(
             shared_logger.error(f"HTMX Run Shared: Agent '{start_agent_name}' not found in shared Flock '{temp_flock.name}'.")
             return HTMLResponse(f"<p class='error'>Agent '{start_agent_name}' not found in the provided shared Flock definition.</p>")
 
-        # Parse inputs for the agent from the temporary flock
         if agent.input and isinstance(agent.input, str):
             parsed_spec = parse_schema(agent.input)
             for name, type_str, _ in parsed_spec:
-                form_field_name = f"agent_input_{name}" # Name used in shared_run_page.html
+                form_field_name = f"agent_input_{name}"
                 raw_value = form_data.get(form_field_name)
-
-                # Input type conversion (consistent with the other endpoint)
                 if raw_value is None and "bool" in type_str.lower(): inputs[name] = False; continue
                 if raw_value is None: inputs[name] = None; continue
                 if "int" in type_str.lower(): inputs[name] = int(raw_value)
@@ -234,31 +215,85 @@ 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)
+        # 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'}")
 
-        # Process and serialize result for template (same logic as other endpoint)
-        try:
-            processed_result = pydantic_to_dict(result_data)
-            try: json.dumps(processed_result)
-            except (TypeError, ValueError) as ser_e:
-                processed_result = f"Error: Result contains non-serializable data: {ser_e!s}\nOriginal result preview: {str(result_data)[:500]}..."
-                shared_logger.warning(f"HTMX Run Shared: Serialization issue: {processed_result}")
-        except Exception as proc_e:
-            processed_result = f"Error: Failed to process result data: {proc_e!s}"
-            shared_logger.error(f"HTMX Run Shared: Result processing error: {processed_result}", exc_info=True)
-
-        return templates.TemplateResponse(
-            "partials/_results_display.html",
-            {"request": request, "result_data": processed_result},
-        )
-
-    except ValueError as ve: # Catch specific input parsing errors
-        shared_logger.error(f"HTMX Run Shared: Input parsing error for agent '{start_agent_name}': {ve}", exc_info=True)
+    except ValueError as ve:
+        shared_logger.error(f"HTMX Run Shared: Input parsing error for '{start_agent_name}' (share_id: {share_id}): {ve}", exc_info=True)
         return HTMLResponse(f"<p class='error'>Invalid input format: {ve!s}</p>")
-    except Exception as e_general:
-        error_message = f"An unexpected error occurred during shared execution: {e_general!s}"
-        shared_logger.error(f"HTMX Run Shared: General error for agent '{start_agent_name}': {e_general}", exc_info=True)
-        return templates.TemplateResponse(
-            "partials/_results_display.html",
-            {"request": request, "result_data": {"error": error_message } },
-        )
+    except Exception as e:
+        shared_logger.error(f"HTMX Run Shared: Error during execution for '{start_agent_name}' (share_id: {share_id}): {e}", exc_info=True)
+        return HTMLResponse(f"<p class='error'>An unexpected error occurred: {e!s}</p>")
+
+    return templates.TemplateResponse(
+        "partials/_results_display.html",
+        {
+            "request": request,
+            "result": result_data,
+            "result_raw_json": result_data_raw_json_str,
+            "feedback_endpoint": "/ui/api/flock/htmx/feedback-shared",
+            "share_id": share_id,
+            "flock_name": temp_flock.name,
+            "agent_name": start_agent_name,
+            "flock_definition": temp_flock.to_yaml(),
+        }
+    )
+
+# --- Feedback endpoints ---
+@router.post("/htmx/feedback", response_class=HTMLResponse)
+async def htmx_submit_feedback(
+    request: Request,
+    reason: str = Form(...),
+    expected_response: str | None = Form(None),
+    actual_response: str | None = Form(None),
+    flock_name: str | None = Form(None),
+    agent_name: str | None = Form(None),
+    flock_definition: str | None = Form(None),
+    store: SharedLinkStoreInterface = Depends(get_shared_link_store),
+):
+    from uuid import uuid4
+
+    from flock.webapp.app.services.sharing_models import FeedbackRecord
+
+    record = FeedbackRecord(
+        feedback_id=uuid4().hex,
+        share_id=None,
+        context_type="agent_run",
+        reason=reason,
+        expected_response=expected_response,
+        actual_response=actual_response,
+        flock_name=flock_name,
+        agent_name=agent_name,
+        flock_definition=flock_definition,
+    )
+    await store.save_feedback(record)
+    return HTMLResponse("<p>🙏 Feedback received – thank you!</p>")
+
+
+@router.post("/htmx/feedback-shared", response_class=HTMLResponse)
+async def htmx_submit_feedback_shared(
+    request: Request,
+    share_id: str = Form(...),
+    reason: str = Form(...),
+    expected_response: str | None = Form(None),
+    actual_response: str | None = Form(None),
+    flock_definition: str | None = Form(None),
+    store: SharedLinkStoreInterface = Depends(get_shared_link_store),
+):
+    from uuid import uuid4
+
+    from flock.webapp.app.services.sharing_models import FeedbackRecord
+
+    record = FeedbackRecord(
+        feedback_id=uuid4().hex,
+        share_id=share_id,
+        context_type="agent_run",
+        reason=reason,
+        expected_response=expected_response,
+        actual_response=actual_response,
+        flock_definition=flock_definition,
+    )
+    await store.save_feedback(record)
+    return HTMLResponse("<p>🙏 Feedback received for shared run – thank you!</p>")

flock/webapp/app/chat.py

@@ -6,7 +6,7 @@ from datetime import datetime
 from uuid import uuid4
 
 import markdown2  # Added for Markdown to HTML conversion
-from fastapi import APIRouter, Depends, Form, Request
+from fastapi import APIRouter, Depends, Form, Request, Response
 from fastapi.responses import HTMLResponse
 from pydantic import BaseModel
 
@@ -14,7 +14,10 @@ from flock.core.flock import Flock
 from flock.core.logging.logging import get_logger
 from flock.webapp.app.dependencies import get_shared_link_store
 from flock.webapp.app.main import get_base_context_web, templates
-from flock.webapp.app.services.sharing_models import SharedLinkConfig
+from flock.webapp.app.services.sharing_models import (
+    FeedbackRecord,
+    SharedLinkConfig,
+)
 from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
 
 router = APIRouter()
@@ -224,7 +227,15 @@ async def chat_send(request: Request, message: str = Form(...)):
             # If even echo should be markdown, remove is_error=True here and let it pass through. For now, plain.
 
     duration_ms = int((datetime.now() - start_time).total_seconds() * 1000)
-    history.append({"role": "bot", "text": bot_text, "timestamp": current_time, "agent": bot_agent or "echo", "duration_ms": duration_ms})
+    history.append({
+        "role": "bot",
+        "text": bot_text,
+        "timestamp": current_time,
+        "agent": bot_agent or "echo",
+        "duration_ms": duration_ms,
+        "raw_json": original_bot_text if 'original_bot_text' in locals() else bot_text,
+        "flock_yaml": getattr(flock_inst, 'to_yaml', lambda: "")()
+    })
     # Return updated history partial
     return templates.TemplateResponse(
         "partials/_chat_messages.html",
@@ -272,7 +283,7 @@ async def chat_settings_form(request: Request):
     return templates.TemplateResponse("partials/_chat_settings_form.html", context)
 
 
-@router.post("/chat/settings", response_class=HTMLResponse, include_in_schema=False)
+@router.post("/chat/settings", include_in_schema=False)
 async def chat_settings_submit(
     request: Request,
     agent_name: str | None = Form(default=None),
@@ -280,19 +291,23 @@ async def chat_settings_submit(
     history_key: str = Form("history"),
     response_key: str = Form("response"),
 ):
-    """Apply submitted chat config, then re-render the form with a success message."""
+    """Handles chat settings submission and triggers a toast notification."""
     cfg = get_chat_config(request)
-    cfg.agent_name = agent_name or None
+    cfg.agent_name = agent_name
     cfg.message_key = message_key
     cfg.history_key = history_key
     cfg.response_key = response_key
 
-    headers = {
-        "HX-Trigger": json.dumps({"notify": {"type": "success", "message": "Chat settings saved"}}),
-        "HX-Redirect": "/chat"
+    logger.info(f"Chat settings updated: Agent: {cfg.agent_name}, MsgKey: {cfg.message_key}, HistKey: {cfg.history_key}, RespKey: {cfg.response_key}")
+
+    toast_event = {
+        "showGlobalToast": {
+            "message": "Chat settings saved successfully!",
+            "type": "success"
+        }
     }
-    # Response body empty; HTMX will redirect
-    return HTMLResponse("", headers=headers)
+    headers = {"HX-Trigger": json.dumps(toast_event)}
+    return Response(status_code=204, headers=headers)
 
 
 # --- Stand-alone Chat HTML page access to settings --------------------------
@@ -512,9 +527,78 @@ async def chat_send_shared(
              bot_text = f"Shared Echo: {message}"
 
     duration_ms = int((datetime.now() - start_time).total_seconds() * 1000)
-    history.append({"role": "bot", "text": bot_text, "timestamp": current_time, "agent": bot_agent or "shared-echo", "duration_ms": duration_ms})
+    history.append({
+        "role": "bot",
+        "text": bot_text,
+        "timestamp": current_time,
+        "agent": bot_agent or "shared-echo",
+        "duration_ms": duration_ms,
+        "raw_json": original_bot_text if 'original_bot_text' in locals() else bot_text,
+        "flock_yaml": getattr(flock_inst, 'to_yaml', lambda: "")()
+    })
 
     return templates.TemplateResponse(
         "partials/_chat_messages.html",
         {"request": request, "history": history, "now": datetime.now}
     )
+
+# ---------------- Feedback endpoints ----------------
+@router.post("/chat/htmx/feedback", response_class=HTMLResponse, include_in_schema=False)
+async def chat_feedback(request: Request,
+    reason: str = Form(...),
+    expected_response: str | None = Form(None),
+    actual_response: str | None = Form(None),
+    flock_definition: str | None = Form(None),
+    agent_name: str | None = Form(None),
+    store: SharedLinkStoreInterface = Depends(get_shared_link_store)):
+    from uuid import uuid4
+    rec = FeedbackRecord(
+        feedback_id=uuid4().hex,
+        share_id=None,
+        context_type="chat",
+        reason=reason,
+        expected_response=expected_response,
+        actual_response=actual_response,
+        flock_definition=flock_definition,
+        agent_name=agent_name,
+    )
+    await store.save_feedback(rec)
+    toast_event = {
+        "showGlobalToast": {
+            "message": "Feedback received! Thanks",
+            "type": "success"
+        }
+    }
+    headers = {"HX-Trigger": json.dumps(toast_event)}
+    return Response(status_code=204, headers=headers)
+
+
+@router.post("/chat/htmx/feedback-shared", response_class=HTMLResponse, include_in_schema=False)
+async def chat_feedback_shared(request: Request,
+    share_id: str = Form(...),
+    reason: str = Form(...),
+    expected_response: str | None = Form(None),
+    actual_response: str | None = Form(None),
+    flock_definition: str | None = Form(None),
+    agent_name: str | None = Form(None),
+    store: SharedLinkStoreInterface = Depends(get_shared_link_store)):
+    from uuid import uuid4
+    rec = FeedbackRecord(
+        feedback_id=uuid4().hex,
+        share_id=share_id,
+        context_type="chat",
+        reason=reason,
+        expected_response=expected_response,
+        actual_response=actual_response,
+        flock_definition=flock_definition,
+        agent_name=agent_name,
+    )
+    await store.save_feedback(rec)
+    toast_event = {
+        "showGlobalToast": {
+            "message": "Feedback received! Thanks",
+            "type": "success"
+        }
+    }
+    headers = {"HX-Trigger": json.dumps(toast_event)}
+    return Response(status_code=204, headers=headers)

flock/webapp/app/config.py

@@ -38,7 +38,7 @@ THEMES_DIR = FLOCK_BASE_DIR / "themes"
 CURRENT_FLOCK_INSTANCE: "Flock | None" = None
 CURRENT_FLOCK_FILENAME: str | None = None
 
-DEFAULT_THEME_NAME = OutputTheme.everblush.value # Default if random fails or invalid theme specified
+DEFAULT_THEME_NAME = OutputTheme.ciapre.value # Default if random fails or invalid theme specified
 
 def list_available_themes() -> list[str]:
     """Scans the THEMES_DIR for .toml files and returns their names (without .toml)."""

flock/webapp/app/main.py

@@ -9,6 +9,7 @@ import uuid
 from contextlib import asynccontextmanager
 from pathlib import Path
 
+import markdown2  # Import markdown2
 from fastapi import (
     Depends,
     FastAPI,
@@ -237,6 +238,12 @@ 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"))
 
+# Add markdown2 filter to Jinja2 environment
+def markdown_filter(text):
+    return markdown2.markdown(text, extras=["tables", "fenced-code-blocks"])
+
+templates.env.filters['markdown'] = markdown_filter
+
 core_api_router = create_api_router()
 app.include_router(core_api_router, prefix="/api", tags=["Flock API Core"])
 app.include_router(flock_management.router, prefix="/ui/api/flock", tags=["UI Flock Management"])
@@ -758,11 +765,10 @@ async def ui_load_flock_by_name_action(request: Request, selected_flock_filename
     ui_mode_query = request.query_params.get("ui_mode", "standalone")
     if loaded_flock:
         success_message_text = f"Flock '{loaded_flock.name}' loaded from '{selected_flock_filename}'."
-        response_headers["HX-Push-Url"] = "/ui/editor/properties?ui_mode=" + request.query_params.get("ui_mode", "standalone")
+        response_headers["HX-Push-Url"] = "/ui/editor/execute?ui_mode=" + ui_mode_query
         response_headers["HX-Trigger"] = json.dumps({"flockLoaded": None, "notify": {"type": "success", "message": success_message_text}})
-        # Use get_base_context_web to ensure all necessary context vars are present for the partial
         context = get_base_context_web(request, success=success_message_text, ui_mode=ui_mode_query)
-        return templates.TemplateResponse("partials/_flock_properties_form.html", context, headers=response_headers)
+        return templates.TemplateResponse("partials/_execution_view_container.html", context, headers=response_headers)
     else:
         error_message_text = f"Failed to load flock file '{selected_flock_filename}'."
         response_headers["HX-Trigger"] = json.dumps({"notify": {"type": "error", "message": error_message_text}})
@@ -790,16 +796,14 @@ async def ui_load_flock_by_upload_action(request: Request, flock_file_upload: Up
         loaded_flock = load_flock_from_file_service(filename_to_load, request.app.state)
         if loaded_flock:
             success_message_text = f"Flock '{loaded_flock.name}' loaded from '{filename_to_load}'."
-            response_headers["HX-Push-Url"] = f"/ui/editor/properties?ui_mode={ui_mode_query}"
+            response_headers["HX-Push-Url"] = f"/ui/editor/execute?ui_mode={ui_mode_query}"
             response_headers["HX-Trigger"] = json.dumps({"flockLoaded": None, "flockFileListChanged": None, "notify": {"type": "success", "message": success_message_text}})
-            # CORRECTED CALL:
             context = get_base_context_web(request, success=success_message_text, ui_mode=ui_mode_query)
-            return templates.TemplateResponse("partials/_flock_properties_form.html", context, headers=response_headers)
+            return templates.TemplateResponse("partials/_execution_view_container.html", context, headers=response_headers)
         else: error_message_text = f"Failed to process uploaded '{filename_to_load}'."
 
     final_error_msg = error_message_text or "Upload failed."
     response_headers["HX-Trigger"] = json.dumps({"notify": {"type": "error", "message": final_error_msg}})
-    # CORRECTED CALL:
     context = get_base_context_web(request, error=final_error_msg, ui_mode=ui_mode_query)
     return templates.TemplateResponse("partials/_create_flock_form.html", context, headers=response_headers)
 
@@ -807,16 +811,14 @@ async def ui_load_flock_by_upload_action(request: Request, flock_file_upload: Up
 async def ui_create_flock_action(request: Request, flock_name: str = Form(...), default_model: str = Form(None), description: str = Form(None)):
     ui_mode_query = request.query_params.get("ui_mode", "standalone")
     if not flock_name.strip():
-        # CORRECTED CALL:
         context = get_base_context_web(request, error="Flock name cannot be empty.", ui_mode=ui_mode_query)
         return templates.TemplateResponse("partials/_create_flock_form.html", context)
 
     new_flock = create_new_flock_service(flock_name, default_model, description, request.app.state)
-    success_msg_text = f"New flock '{new_flock.name}' created. Configure properties and save."
-    response_headers = {"HX-Push-Url": f"/ui/editor/properties?ui_mode={ui_mode_query}", "HX-Trigger": json.dumps({"flockLoaded": None, "notify": {"type": "success", "message": success_msg_text}})}
-    # CORRECTED CALL:
+    success_msg_text = f"New flock '{new_flock.name}' created. Navigating to Execute page. Configure properties and agents as needed."
+    response_headers = {"HX-Push-Url": f"/ui/editor/execute?ui_mode={ui_mode_query}", "HX-Trigger": json.dumps({"flockLoaded": None, "notify": {"type": "success", "message": success_msg_text}})}
     context = get_base_context_web(request, success=success_msg_text, ui_mode=ui_mode_query)
-    return templates.TemplateResponse("partials/_flock_properties_form.html", context, headers=response_headers)
+    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"])

flock/webapp/app/services/sharing_models.py

@@ -41,3 +41,41 @@ class SharedLinkConfig(BaseModel):
             ]
         }
     }
+
+# -----------------------------------------------------------
+# Feedback model (user ratings / corrections)
+# -----------------------------------------------------------
+
+
+class FeedbackRecord(BaseModel):
+    """A user-submitted piece of feedback for an agent run or chat turn."""
+
+    feedback_id: str = Field(..., description="Unique identifier for this feedback entry.")
+    share_id: str | None = Field(None, description="If the feedback refers to a shared link, its ID; otherwise None.")
+    context_type: str = Field(
+        default="agent_run",
+        description="Where the feedback originates (agent_run | chat | other)",
+    )
+    reason: str = Field(..., description="User-supplied reason / comment.")
+    expected_response: str | None = Field(
+        None,
+        description="Desired or corrected response in JSON or plain text.",
+    )
+    actual_response: str | None = Field(
+        None,
+        description="Original response shown to the user (optional, for context).",
+    )
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    # When share_id is None store explicit target identifiers
+    flock_name: str | None = Field(
+        None,
+        description="Name of the flock that produced the result when no share_id is used.",
+    )
+    agent_name: str | None = Field(
+        None,
+        description="Name of the agent or chat involved in the feedback.",
+    )
+    flock_definition: str | None = Field(
+        None,
+        description="Full YAML definition of the flock when feedback was submitted.",
+    )

flock/webapp/app/services/sharing_store.py

@@ -5,7 +5,10 @@ from pathlib import Path
 
 import aiosqlite
 
-from flock.webapp.app.services.sharing_models import SharedLinkConfig
+from flock.webapp.app.services.sharing_models import (
+    FeedbackRecord,
+    SharedLinkConfig,
+)
 
 # Get a logger instance
 logger = logging.getLogger(__name__)
@@ -33,6 +36,12 @@ class SharedLinkStoreInterface(ABC):
         """Deletes a shared link configuration by its ID. Returns True if deleted, False otherwise."""
         pass
 
+    # Feedback
+    @abstractmethod
+    async def save_feedback(self, record: FeedbackRecord):
+        """Persist a feedback record."""
+        pass
+
 class SQLiteSharedLinkStore(SharedLinkStoreInterface):
     """SQLite implementation for storing and retrieving shared link configurations."""
 
@@ -76,6 +85,25 @@ class SQLiteSharedLinkStore(SharedLinkStoreInterface):
                         else:
                             raise # Re-raise if it's a different operational error
 
+                # Feedback table
+                await db.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS feedback (
+                        feedback_id TEXT PRIMARY KEY,
+                        share_id TEXT,
+                        context_type TEXT NOT NULL,
+                        reason TEXT NOT NULL,
+                        expected_response TEXT,
+                        actual_response TEXT,
+                        flock_name TEXT,
+                        agent_name TEXT,
+                        flock_definition TEXT,
+                        created_at TEXT NOT NULL,
+                        FOREIGN KEY(share_id) REFERENCES shared_links(share_id)
+                    )
+                    """
+                )
+
                 await db.commit()
             logger.info(f"Database initialized and shared_links table schema ensured at {self.db_path}")
         except sqlite3.Error as e:
@@ -154,3 +182,34 @@ class SQLiteSharedLinkStore(SharedLinkStoreInterface):
         except sqlite3.Error as e:
             logger.error(f"SQLite error deleting config for ID {share_id}: {e}", exc_info=True)
             return False # Or raise
+
+    # ----------------------- Feedback methods -----------------------
+
+    async def save_feedback(self, record: FeedbackRecord) -> FeedbackRecord:
+        """Persist a feedback record to SQLite."""
+        try:
+            async with aiosqlite.connect(self.db_path) as db:
+                await db.execute(
+                    """INSERT INTO feedback (
+                        feedback_id, share_id, context_type, reason,
+                        expected_response, actual_response, flock_name, agent_name, flock_definition, created_at
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                    (
+                        record.feedback_id,
+                        record.share_id,
+                        record.context_type,
+                        record.reason,
+                        record.expected_response,
+                        record.actual_response,
+                        record.flock_name,
+                        record.agent_name,
+                        record.flock_definition,
+                        record.created_at.isoformat(),
+                    ),
+                )
+                await db.commit()
+            logger.info(f"Saved feedback {record.feedback_id} (share={record.share_id})")
+            return record
+        except sqlite3.Error as e:
+            logger.error(f"SQLite error saving feedback {record.feedback_id}: {e}", exc_info=True)
+            raise

flock/webapp/static/css/chat.css

@@ -39,6 +39,8 @@ body.chat-page {
     background-position: 0 0, 10px 10px;
 }
 
+
+
 .bubble { 
     position: relative;
     padding: 0.75rem 1rem;