flock-core 0.5.0b28__py3-none-any.whl → 0.5.56b0__py3-none-any.whl

flock/webapp/app/chat.py

@@ -1,665 +0,0 @@
-from __future__ import annotations
-
-import ast  # Add import ast
-import json
-from datetime import datetime
-from typing import Literal
-from uuid import uuid4
-
-import markdown2  # Added for Markdown to HTML conversion
-from fastapi import APIRouter, Depends, Form, Request, Response
-from fastapi.responses import FileResponse, HTMLResponse
-from pydantic import BaseModel
-
-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.feedback_file_service import (
-    create_csv_feedback_file,
-    create_csv_feedback_file_for_agent,
-    create_xlsx_feedback_file,
-    create_xlsx_feedback_file_for_agent,
-)
-from flock.webapp.app.services.sharing_models import (
-    FeedbackRecord,
-    SharedLinkConfig,
-)
-from flock.webapp.app.services.sharing_store import SharedLinkStoreInterface
-
-router = APIRouter()
-logger = get_logger("webapp.chat")
-
-# ---------------------------------------------------------------------------
-# In-memory session store (cookie-based). Not suitable for production scale.
-# ---------------------------------------------------------------------------
-_chat_sessions: dict[str, list[dict[str, str]]] = {}
-
-COOKIE_NAME = "chat_sid"
-
-
-def _ensure_session(request: Request) -> tuple[str, list[dict[str, str]]]:
-    """Returns (sid, history_list) tuple and guarantees cookie presence."""
-    sid: str | None = request.cookies.get(COOKIE_NAME)
-    if not sid:
-        sid = uuid4().hex
-    if sid not in _chat_sessions:
-        _chat_sessions[sid] = []
-    return sid, _chat_sessions[sid]
-
-
-def _get_history_for_shared_chat(request: Request, share_id: str) -> list[dict[str, str]]:
-    """Manages history for a shared chat session, namespaced by share_id and user's session_id."""
-    user_sid: str | None = request.cookies.get(COOKIE_NAME)
-    if not user_sid: # Should have been set by _ensure_session on page load
-        user_sid = uuid4().hex
-        # Note: This history will be ephemeral if the cookie isn't set back to the client,
-        # but _ensure_session on the shared chat page load should handle cookie setting.
-
-    # Composite key for shared chat history
-    shared_session_key = f"shared_{share_id}_{user_sid}"
-    if shared_session_key not in _chat_sessions:
-        _chat_sessions[shared_session_key] = []
-    return _chat_sessions[shared_session_key]
-
-
-# ---------------------------------------------------------------------------
-# Chat configuration (per app instance for non-shared, or from SharedLinkConfig for shared)
-# ---------------------------------------------------------------------------
-
-
-class ChatConfig(BaseModel):
-    agent_name: str | None = None  # Name of the Flock agent to chat with
-    message_key: str = "message"
-    history_key: str = "history"
-    response_key: str = "response"
-
-
-# Store a single global chat config on the FastAPI app state for non-shared chat
-def get_chat_config(request: Request) -> ChatConfig:
-    if not hasattr(request.app.state, "chat_config"):
-        request.app.state.chat_config = ChatConfig()
-    return request.app.state.chat_config
-
-
-# ---------------------------------------------------------------------------
-# Helper for Shared Chat Context
-# ---------------------------------------------------------------------------
-async def _get_shared_chat_context(
-    request: Request,
-    share_id: str,
-    store: SharedLinkStoreInterface = Depends(get_shared_link_store)
-) -> tuple[ChatConfig | None, Flock | None, SharedLinkConfig | None]:
-    shared_config_db = await store.get_config(share_id)
-
-    if not shared_config_db or shared_config_db.share_type != "chat":
-        logger.warning(f"Shared chat link {share_id} not found or not a chat share type.")
-        return None, None, None
-
-    # Retrieve the pre-loaded Flock instance for this share_id
-    # This is loaded by the /chat/shared/{share_id} endpoint in main.py (or will be)
-    # For chat.py, we will create a specific /chat/shared/{share_id} endpoint
-
-    loaded_flock: Flock | None = None
-    if hasattr(request.app.state, 'shared_flocks') and share_id in request.app.state.shared_flocks:
-        loaded_flock = request.app.state.shared_flocks[share_id]
-    else:
-        # Attempt to load on-the-fly if not found (e.g., direct API call without page load)
-        # This is a fallback and might be slower if the Flock definition is large.
-        # The main /chat/shared/{share_id} page route should pre-load this.
-        try:
-            from flock.core.flock import Flock as ConcreteFlock  # Local import
-            loaded_flock = ConcreteFlock.from_yaml(shared_config_db.flock_definition)
-            if not hasattr(request.app.state, 'shared_flocks'):
-                request.app.state.shared_flocks = {}
-            request.app.state.shared_flocks[share_id] = loaded_flock # Cache it
-            logger.info(f"On-the-fly load of Flock for shared chat {share_id}.")
-        except Exception as e_load:
-            logger.error(f"Failed to load Flock from definition for shared chat {share_id}: {e_load}", exc_info=True)
-            return None, None, shared_config_db
-
-
-    frozen_chat_cfg = ChatConfig(
-        agent_name=shared_config_db.agent_name, # agent_name from SharedLinkConfig is the chat agent
-        message_key=shared_config_db.chat_message_key or "message",
-        history_key=shared_config_db.chat_history_key or "history",
-        response_key=shared_config_db.chat_response_key or "response",
-    )
-    return frozen_chat_cfg, loaded_flock, shared_config_db
-
-
-# ---------------------------------------------------------------------------
-# Routes
-# ---------------------------------------------------------------------------
-
-
-@router.get("/chat", response_class=HTMLResponse, tags=["Chat"])
-async def chat_page(request: Request):
-    """Full-page chat UI (works even when the main UI is disabled)."""
-    sid, history = _ensure_session(request)
-    cfg = get_chat_config(request)
-    context = get_base_context_web(request, ui_mode="standalone")
-    context.update({"history": history, "chat_cfg": cfg, "chat_subtitle": f"Agent: {cfg.agent_name}" if cfg.agent_name else "Echo demo", "is_shared_chat": False, "share_id": None})
-    response = templates.TemplateResponse("chat.html", context)
-    # Set cookie if not already present
-    if COOKIE_NAME not in request.cookies:
-        response.set_cookie(COOKIE_NAME, sid, max_age=60 * 60 * 24 * 7)
-    return response
-
-
-@router.get("/chat/messages", response_class=HTMLResponse, tags=["Chat"], include_in_schema=False)
-async def chat_history_partial(request: Request):
-    """HTMX endpoint that returns the rendered message list."""
-    _, history = _ensure_session(request)
-    return templates.TemplateResponse(
-        "partials/_chat_messages.html",
-        {"request": request, "history": history, "now": datetime.now}
-    )
-
-
-@router.post("/chat/send", response_class=HTMLResponse, tags=["Chat"])
-async def chat_send(request: Request, message: str = Form(...)):
-    """Echo-back mock implementation. Adds user msg + bot reply to history."""
-    _, history = _ensure_session(request)
-    current_time = datetime.now().strftime('%H:%M')
-    cfg = get_chat_config(request)
-    history.append({"role": "user", "text": message, "timestamp": current_time})
-    start_time = datetime.now()
-    is_error = False # Initialize is_error
-
-    flock_inst = getattr(request.app.state, "flock_instance", None)
-    bot_agent = cfg.agent_name if cfg.agent_name else None
-    bot_text: str
-
-    if bot_agent and flock_inst and bot_agent in getattr(flock_inst, "agents", {}):
-        run_input: dict = {}
-        if cfg.message_key: run_input[cfg.message_key] = message
-        if cfg.history_key: run_input[cfg.history_key] = [h["text"] for h in history if h.get("role") == "user" or h.get("role") == "bot"] # Simple text history
-
-        try:
-            result_dict = await flock_inst.run_async(start_agent=bot_agent, input=run_input, box_result=False)
-            # Assuming result_dict might be the actual dict, or its string representation is what we need.
-            # For now, we work with bot_text derived from it.
-            if cfg.response_key:
-                bot_text = str(result_dict.get(cfg.response_key, result_dict))
-            else:
-                bot_text = str(result_dict)
-
-        except Exception as e:
-            bot_text = f"Error: {e}"
-            is_error = True
-
-        if not is_error:
-            original_bot_text = bot_text # Keep a copy
-            formatted_as_json = False
-
-            stripped_text = bot_text.strip()
-            if (stripped_text.startswith('{') and stripped_text.endswith('}')) or \
-               (stripped_text.startswith('[') and stripped_text.endswith(']')):
-                try:
-                    parsed_obj = json.loads(bot_text)
-                    if isinstance(parsed_obj, (dict, list)):
-                        pretty_json = json.dumps(parsed_obj, indent=2).replace('\\n', '\n')
-                        bot_text = f'''<pre><code class="language-json">{pretty_json}</code></pre>'''
-                        formatted_as_json = True
-                except json.JSONDecodeError:
-                    try:
-                        evaluated_obj = ast.literal_eval(bot_text)
-                        if isinstance(evaluated_obj, (dict, list)):
-                            pretty_json = json.dumps(evaluated_obj, indent=2).replace('\\n', '\n')
-                            bot_text = f'''<pre><code class="language-json">{pretty_json}</code></pre>'''
-                            formatted_as_json = True
-                    except (ValueError, SyntaxError, TypeError):
-                        pass # Fall through
-                except Exception as e_json_fmt:
-                    logger.error(f"Error formatting likely JSON: {e_json_fmt}. Original: {original_bot_text[:200]}", exc_info=True)
-                    bot_text = original_bot_text
-
-            if not formatted_as_json:
-                try:
-                    bot_text = markdown2.markdown(original_bot_text, extras=["fenced-code-blocks", "tables", "break-on-newline"])
-                except Exception:
-                    logger.error(f"Error during Markdown conversion for bot_text. Original: {original_bot_text[:200]}", exc_info=True)
-                    bot_text = original_bot_text # Fallback to original text, will be HTML escaped by Jinja if not |safe
-
-    else:
-        # Fallback echo behavior or agent not found messages
-        is_error = True # Treat these as plain text, no special formatting
-        if bot_agent and not flock_inst:
-            bot_text = f"Agent '{bot_agent}' configured, but no Flock loaded."
-        elif bot_agent and flock_inst and bot_agent not in getattr(flock_inst, "agents", {}):
-             bot_text = f"Agent '{bot_agent}' configured, but not found in the loaded Flock."
-        else: # No agent configured
-            bot_text = f"Echo: {message}"
-            # 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,
-        "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",
-        {"request": request, "history": history, "now": datetime.now}
-    )
-
-
-@router.get("/ui/htmx/chat-view", response_class=HTMLResponse, tags=["Chat"], include_in_schema=False)
-async def chat_container_partial(request: Request):
-    _ensure_session(request)
-    return templates.TemplateResponse("partials/_chat_container.html", {"request": request})
-
-
-# ---------------------------------------------------------------------------
-# Chat settings management
-# ---------------------------------------------------------------------------
-
-
-@router.get("/ui/htmx/chat-settings-form", response_class=HTMLResponse, include_in_schema=False)
-async def chat_settings_form(request: Request):
-    """Returns the form for configuring chat behaviour (HTMX partial)."""
-    cfg = get_chat_config(request)
-    flock_inst = getattr(request.app.state, "flock_instance", None)
-    input_fields, output_fields = [], []
-    if cfg.agent_name and flock_inst and cfg.agent_name in flock_inst.agents:
-        agent_obj = flock_inst.agents[cfg.agent_name]
-        # Expect signatures like "field: type | desc, ..." or "field: type" etc.
-        def _extract(sig: str):
-            fields = []
-            for seg in sig.split(','):
-                parts = seg.strip().split(':')
-                if parts:
-                    fields.append(parts[0].strip())
-            return [f for f in fields if f]
-        input_fields = _extract(agent_obj.input) if getattr(agent_obj, 'input', '') else []
-        output_fields = _extract(agent_obj.output) if getattr(agent_obj, 'output', '') else []
-
-    context = get_base_context_web(request)
-    context.update({
-        "chat_cfg": cfg,
-        "current_flock": flock_inst,
-        "input_fields": input_fields,
-        "output_fields": output_fields,
-    })
-    return templates.TemplateResponse("partials/_chat_settings_form.html", context)
-
-
-@router.post("/chat/settings", include_in_schema=False)
-async def chat_settings_submit(
-    request: Request,
-    agent_name: str | None = Form(default=None),
-    message_key: str = Form("message"),
-    history_key: str = Form("history"),
-    response_key: str = Form("response"),
-):
-    """Handles chat settings submission and triggers a toast notification."""
-    cfg = get_chat_config(request)
-    cfg.agent_name = agent_name
-    cfg.message_key = message_key
-    cfg.history_key = history_key
-    cfg.response_key = response_key
-
-    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"
-        }
-    }
-    headers = {"HX-Trigger": json.dumps(toast_event)}
-    return Response(status_code=204, headers=headers)
-
-
-# --- Stand-alone Chat HTML page access to settings --------------------------
-
-
-@router.get("/chat/settings-standalone", response_class=HTMLResponse, tags=["Chat"], include_in_schema=False)
-async def chat_settings_standalone(request: Request):
-    """Standalone page to render chat settings (used by full-page chat HTML)."""
-    cfg = get_chat_config(request)
-    context = get_base_context_web(request, ui_mode="standalone")
-    context.update({
-        "chat_cfg": cfg,
-        "current_flock": getattr(request.app.state, "flock_instance", None),
-    })
-    return templates.TemplateResponse("chat_settings.html", context)
-
-
-# ---------------------------------------------------------------------------
-# Stand-alone HTMX partials (chat view & settings) for in-page swapping
-# ---------------------------------------------------------------------------
-
-
-@router.get("/chat/htmx/chat-view", response_class=HTMLResponse, include_in_schema=False)
-async def htmx_chat_view(request: Request):
-    """Return chat container partial for standalone page reload via HTMX."""
-    _ensure_session(request)
-    return templates.TemplateResponse("partials/_chat_container.html", {"request": request})
-
-
-@router.get("/chat/htmx/settings-form", response_class=HTMLResponse, include_in_schema=False)
-async def htmx_chat_settings_partial(request: Request):
-    cfg = get_chat_config(request)
-    # Allow temporarily selecting agent via query param without saving
-    agent_override = request.query_params.get("agent_name")
-    if agent_override is not None:
-        cfg = cfg.copy()
-        cfg.agent_name = agent_override or None
-
-    flock_inst = getattr(request.app.state, "flock_instance", None)
-    input_fields, output_fields = [], []
-    if cfg.agent_name and flock_inst and cfg.agent_name in flock_inst.agents:
-        agent_obj = flock_inst.agents[cfg.agent_name]
-        def _extract(sig: str):
-            return [seg.strip().split(':')[0].strip() for seg in sig.split(',') if seg.strip()]
-        input_fields = _extract(agent_obj.input) if getattr(agent_obj, 'input', '') else []
-        output_fields = _extract(agent_obj.output) if getattr(agent_obj, 'output', '') else []
-
-    context = {"request": request, "chat_cfg": cfg, "current_flock": flock_inst, "input_fields": input_fields, "output_fields": output_fields}
-    return templates.TemplateResponse("partials/_chat_settings_form.html", context)
-
-
-# ---------------------------------------------------------------------------
-# Shared Chat Routes
-# ---------------------------------------------------------------------------
-
-@router.get("/chat/shared/{share_id}", response_class=HTMLResponse, tags=["Chat Sharing"])
-async def page_shared_chat(
-    request: Request,
-    share_id: str,
-    store: SharedLinkStoreInterface = Depends(get_shared_link_store)
-):
-    """Serves the chat page for a shared chat session."""
-    logger.info(f"Accessing shared chat page for share_id: {share_id}")
-
-    sid, _ = _ensure_session(request) # Ensures user has a session for history tracking
-
-    shared_config_db = await store.get_config(share_id)
-
-    if not shared_config_db or shared_config_db.share_type != "chat":
-        logger.warning(f"Shared chat link {share_id} not found or not a chat share type.")
-        # Consider rendering an error template or redirecting
-        error_context = get_base_context_web(request, ui_mode="standalone", error="Shared chat link is invalid or has expired.")
-        return templates.TemplateResponse("error_page.html", {**error_context, "error_title": "Invalid Link"}, status_code=404)
-
-    # Load Flock from definition and cache in app.state.shared_flocks
-    loaded_flock: Flock | None = None
-    if hasattr(request.app.state, 'shared_flocks') and share_id in request.app.state.shared_flocks:
-        loaded_flock = request.app.state.shared_flocks[share_id]
-    else:
-        try:
-            from flock.core.flock import Flock as ConcreteFlock
-            loaded_flock = ConcreteFlock.from_yaml(shared_config_db.flock_definition)
-            if not hasattr(request.app.state, 'shared_flocks'):
-                request.app.state.shared_flocks = {}
-            request.app.state.shared_flocks[share_id] = loaded_flock
-            logger.info(f"Loaded and cached Flock for shared chat {share_id} in app.state.shared_flocks.")
-        except Exception as e_load:
-            logger.error(f"Fatal: Could not load Flock from definition for shared chat {share_id}: {e_load}", exc_info=True)
-            error_context = get_base_context_web(request, ui_mode="standalone", error=f"Could not load the shared Flock configuration: {e_load!s}")
-            return templates.TemplateResponse("error_page.html", {**error_context, "error_title": "Configuration Error"}, status_code=500)
-
-    frozen_chat_cfg = ChatConfig(
-        agent_name=shared_config_db.agent_name,
-        message_key=shared_config_db.chat_message_key or "message",
-        history_key=shared_config_db.chat_history_key or "history",
-        response_key=shared_config_db.chat_response_key or "response",
-    )
-
-    # Get history specific to this user and this shared chat
-    history = _get_history_for_shared_chat(request, share_id)
-
-    context = get_base_context_web(request, ui_mode="standalone")
-    context.update({
-        "history": history, # User-specific history for this shared chat
-        "chat_cfg": frozen_chat_cfg, # The "frozen" config from the share link
-        "chat_subtitle": f"Shared Chat - Agent: {frozen_chat_cfg.agent_name}" if frozen_chat_cfg.agent_name else "Shared Echo Chat",
-        "is_shared_chat": True,
-        "share_id": share_id,
-        "flock": loaded_flock # Pass flock for potential display, though backend uses cached one
-    })
-
-    response = templates.TemplateResponse("chat.html", context)
-    if COOKIE_NAME not in request.cookies: # Ensure cookie is set if _ensure_session created a new one
-        response.set_cookie(COOKIE_NAME, sid, max_age=60 * 60 * 24 * 7)
-    return response
-
-@router.get("/chat/messages-shared/{share_id}", response_class=HTMLResponse, tags=["Chat Sharing"], include_in_schema=False)
-async def chat_history_partial_shared(request: Request, share_id: str):
-    """HTMX endpoint that returns the rendered message list for a shared chat."""
-    # _ensure_session called on page load, so cookie should exist for history keying
-    history = _get_history_for_shared_chat(request, share_id)
-    return templates.TemplateResponse(
-        "partials/_chat_messages.html",
-        {"request": request, "history": history, "now": datetime.now}
-    )
-
-@router.post("/chat/send-shared", response_class=HTMLResponse, tags=["Chat Sharing"])
-async def chat_send_shared(
-    request: Request,
-    share_id: str = Form(...),
-    message: str = Form(...),
-    # Note: Dependencies need to be declared at the route level for FastAPI to inject them.
-    # So, we re-declare get_shared_link_store here or pass it to the helper if FastAPI handles sub-dependencies.
-    # For simplicity with current structure, let _get_shared_chat_context handle its own dependency.
-    # We can also make _get_shared_chat_context a Depends() if preferred.
-    store: SharedLinkStoreInterface = Depends(get_shared_link_store)
-):
-    """Handles message sending for a shared chat session."""
-    frozen_chat_cfg, flock_inst, _ = await _get_shared_chat_context(request, share_id, store)
-    is_error = False # Initialize is_error
-
-    if not frozen_chat_cfg or not flock_inst:
-        # Error response if config or flock couldn't be loaded
-        # This history is ephemeral as it won't be saved if the config is bad
-        error_history = [{"role": "bot", "text": "Error: Shared chat configuration is invalid or Flock not found.", "timestamp": datetime.now().strftime('%H:%M')}]
-        return templates.TemplateResponse(
-            "partials/_chat_messages.html",
-            {"request": request, "history": error_history, "now": datetime.now},
-            status_code=404
-        )
-
-    history = _get_history_for_shared_chat(request, share_id)
-    current_time = datetime.now().strftime('%H:%M')
-    history.append({"role": "user", "text": message, "timestamp": current_time})
-    start_time = datetime.now()
-
-    bot_agent = frozen_chat_cfg.agent_name
-    bot_text: str
-
-    if bot_agent and bot_agent in getattr(flock_inst, "agents", {}):
-        run_input: dict = {}
-        if frozen_chat_cfg.message_key: run_input[frozen_chat_cfg.message_key] = message
-        if frozen_chat_cfg.history_key: run_input[frozen_chat_cfg.history_key] = [h["text"] for h in history if h.get("role") == "user" or h.get("role") == "bot"]
-
-        try:
-            result_dict = await flock_inst.run_async(agent=bot_agent, input=run_input, box_result=False)
-            if frozen_chat_cfg.response_key:
-                bot_text = str(result_dict.get(frozen_chat_cfg.response_key, result_dict))
-            else:
-                bot_text = str(result_dict)
-
-        except Exception as e:
-            bot_text = f"Error running agent {bot_agent} in shared chat: {e}"
-            is_error = True
-            logger.error(f"Error in /chat/send-shared (agent: {bot_agent}, share: {share_id}): {e}", exc_info=True)
-
-        if not is_error:
-            original_bot_text = bot_text # Keep a copy
-            formatted_as_json = False
-
-            stripped_text = bot_text.strip()
-            if (stripped_text.startswith('{') and stripped_text.endswith('}')) or \
-               (stripped_text.startswith('[') and stripped_text.endswith(']')):
-                try:
-                    parsed_obj = json.loads(bot_text)
-                    if isinstance(parsed_obj, (dict, list)):
-                        pretty_json = json.dumps(parsed_obj, indent=2).replace('\\n', '\n')
-                        bot_text = f'''<pre><code class="language-json">{pretty_json}</code></pre>'''
-                        formatted_as_json = True
-                except json.JSONDecodeError:
-                    try:
-                        evaluated_obj = ast.literal_eval(bot_text)
-                        if isinstance(evaluated_obj, (dict, list)):
-                            pretty_json = json.dumps(evaluated_obj, indent=2).replace('\\n', '\n')
-                            bot_text = f'''<pre><code class="language-json">{pretty_json}</code></pre>'''
-                            formatted_as_json = True
-                    except (ValueError, SyntaxError, TypeError):
-                        pass # Fall through
-                except Exception as e_json_fmt:
-                    logger.error(f"Error formatting likely JSON (shared chat): {e_json_fmt}. Original: {original_bot_text[:200]}", exc_info=True)
-                    bot_text = original_bot_text
-
-            if not formatted_as_json:
-                try:
-                    bot_text = markdown2.markdown(original_bot_text, extras=["fenced-code-blocks", "tables", "break-on-newline"])
-                except Exception:
-                    logger.error(f"Error during Markdown conversion for shared chat bot_text. Original: {original_bot_text[:200]}", exc_info=True)
-                    bot_text = original_bot_text
-    else:
-        # Fallback if agent misconfigured or not found in the specific shared flock
-        is_error = True # Treat these as plain text
-        if bot_agent and bot_agent not in getattr(flock_inst, "agents", {}):
-             bot_text = f"Agent '{bot_agent}' (shared) not found in its Flock."
-        elif not bot_agent:
-             bot_text = f"No agent configured for this shared chat. Echoing: {message}"
-        else: # Should not happen if frozen_chat_cfg and flock_inst were valid earlier
-             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,
-        "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)
-
-@router.get("/chat/htmx/feedback-download/{format}", response_class=FileResponse, include_in_schema=False)
-async def chat_feedback_download_all(
-    request: Request,
-    format: Literal["csv", "xlsx"] = "csv",
-    store: SharedLinkStoreInterface = Depends(get_shared_link_store)
-):
-    """Download all feedback records for all agents."""
-    if format == "csv":
-        return await create_csv_feedback_file(
-            request=request,
-            store=store,
-            separator=","
-        )
-    elif format == "xlsx":
-        return await create_xlsx_feedback_file(
-            request=request,
-            store=store,
-        )
-    else:
-        from fastapi import HTTPException
-
-        raise HTTPException(
-            status_code=400,
-            detail="Invalid file-format specified. Valid formats are: 'csv', 'xlsx'"
-        )
-
-@router.get("/chat/htmx/feedback-download/{agent_name}/{format}", response_class=FileResponse, include_in_schema=False)
-async def chat_feedback_download(
-    request: Request,
-    agent_name: str,
-    format: Literal["csv", "xlsx"] = "csv",
-    store: SharedLinkStoreInterface = Depends(get_shared_link_store)
-):
-    """Download all feedback records for a specific agent as a File."""
-    if format == "csv":
-        return await create_csv_feedback_file_for_agent(
-            request=request,
-            store=store,
-            separator=",",
-            agent_name=agent_name,
-        )
-    elif format == "xlsx":
-        return await create_xlsx_feedback_file_for_agent(
-            request=request,
-            store=store,
-            agent_name=agent_name,
-        )
-    else:
-        from fastapi import HTTPException
-
-        raise HTTPException(
-            status_code=400,
-            detail="Invalid file-format specified. Valid formats are: 'csv', 'xlsx'"
-        )