flock-core 0.5.0b10__py3-none-any.whl → 0.5.0b12__py3-none-any.whl

flock/components/evaluation/declarative_evaluation_component.py

@@ -2,7 +2,7 @@
 """DeclarativeEvaluationComponent - DSPy-based evaluation using the unified component system."""
 
 from collections.abc import Generator
-from typing import Any
+from typing import Any, override
 
 from temporalio import workflow
 
@@ -29,7 +29,7 @@ class DeclarativeEvaluationConfig(AgentComponentConfig):
     model: str | None = "openai/gpt-4o"
     use_cache: bool = True
     temperature: float = 0.0
-    max_tokens: int = 4096
+    max_tokens: int = 8192
     max_retries: int = 3
     max_tool_calls: int = 10
     stream: bool = Field(
@@ -69,6 +69,14 @@ class DeclarativeEvaluationComponent(
     def __init__(self, **data):
         super().__init__(**data)
 
+    @override
+    def set_model(self, model: str, temperature: float = 0.0, max_tokens: int = 8192) -> None:
+        """Set the model for the evaluation component."""
+        self.config.model = model
+        if "gpt-oss" in model and temperature == 0.0 and max_tokens == 8192:
+            self.config.temperature = 1.0
+            self.config.max_tokens = 32768
+
     async def evaluate_core(
         self,
         agent: Any,

flock/components/utility/output_utility_component.py

@@ -180,7 +180,8 @@ class OutputUtilityComponent(UtilityComponent):
                 max_length=self.config.max_length,
                 render_table=self.config.render_table,
             )
-        self._formatter.display_result(result_to_display, agent.name)
+        model = agent.model if agent.model else context.get_variable("model")
+        self._formatter.display_result(result_to_display, agent.name + " - " + model)
 
         return result  # Return the original, unmodified result
 

flock/core/component/evaluation_component.py

@@ -24,6 +24,12 @@ class EvaluationComponent(AgentComponent):
     - LLMEvaluationComponent (direct LLM API)
     """
 
+    @abstractmethod
+    def set_model(self, model: str, temperature: float = 0.0, max_tokens: int = 4096) -> None:
+        """Set the model for the evaluation component."""
+        pass
+
+
     @abstractmethod
     async def evaluate_core(
         self,

flock/core/flock_agent.py

@@ -258,7 +258,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         """
         self.model = model
         if self.evaluator and hasattr(self.evaluator, "config"):
-            self.evaluator.config.model = model
+            self.evaluator.set_model(model)
             logger.info(
                 f"Set model to '{model}' for agent '{self.name}' and its evaluator."
             )

flock/core/flock_factory.py

@@ -435,6 +435,10 @@ class FlockFactory:
             OutputUtilityConfig,
         )
 
+        if model and "gpt-oss" in model:
+            temperature = 1.0
+            max_tokens = 32768
+
         # Create evaluation component
         eval_config = DeclarativeEvaluationConfig(
             model=model,

flock/core/orchestration/flock_execution.py

@@ -133,7 +133,7 @@ class FlockExecution:
             span.set_attribute("enable_temporal", self.flock.enable_temporal)
 
             logger.info(
-                f"Initiating Flock run '{self.flock.name}'. Start Agent: '{start_agent_name}'. Temporal: {self.flock.enable_temporal}."
+                f"Initiating Flock run '{self.flock.name}'. Model: '{self.flock.model}'. Start Agent: '{start_agent_name}'. Temporal: {self.flock.enable_temporal}."
             )
 
             try:

flock/core/orchestration/flock_initialization.py

@@ -41,7 +41,7 @@ class FlockInitialization:
 
         # Initialize console if needed for banner
         if self.flock.show_flock_banner:
-            init_console(clear_screen=True, show_banner=self.flock.show_flock_banner)
+            init_console(clear_screen=True, show_banner=self.flock.show_flock_banner, model=self.flock.model)
 
         # Set Temporal debug environment variable
         self._set_temporal_debug_flag()

flock/core/util/cli_helper.py

@@ -38,7 +38,7 @@ def display_hummingbird():
 """)
 
 
-def init_console(clear_screen: bool = True, show_banner: bool = True):
+def init_console(clear_screen: bool = True, show_banner: bool = True, model: str = ""):
     """Display the Flock banner."""
     from rich.console import Console
     from rich.syntax import Text
@@ -66,6 +66,9 @@ def init_console(clear_screen: bool = True, show_banner: bool = True):
             "[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
         )
 
+    if model:
+        console.print(f"[italic]Global Model:[/] {model}")
+
 
 def display_banner_no_version():
     """Display the Flock banner."""

flock/webapp/app/api/execution.py

@@ -1,7 +1,8 @@
 # src/flock/webapp/app/api/execution.py
+import html
 import json
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 import markdown2  # Import markdown2
 from fastapi import (  # Ensure Form and HTTPException are imported
@@ -11,8 +12,16 @@ from fastapi import (  # Ensure Form and HTTPException are imported
     Request,
 )
 from fastapi.encoders import jsonable_encoder
-from fastapi.responses import HTMLResponse
+from fastapi.responses import FileResponse, HTMLResponse
 from fastapi.templating import Jinja2Templates
+from werkzeug.utils import secure_filename
+
+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,
+)
 
 if TYPE_CHECKING:
     from flock.core.flock import Flock
@@ -41,26 +50,30 @@ 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
+
+templates.env.filters["markdown"] = markdown_filter
 
 
 @router.get("/htmx/execution-form-content", response_class=HTMLResponse)
 async def htmx_get_execution_form_content(
     request: Request,
-    current_flock: "Flock | None" = Depends(get_optional_flock_instance) # Use optional if form can show 'no flock'
+    current_flock: "Flock | None" = Depends(
+        get_optional_flock_instance
+    ),  # Use optional if form can show 'no flock'
 ):
     # flock instance is injected
     return templates.TemplateResponse(
         "partials/_execution_form.html",
         {
             "request": request,
-            "flock": current_flock, # Pass the injected flock instance
+            "flock": current_flock,  # Pass the injected flock instance
             "input_fields": [],
-            "selected_agent_name": None, # Form starts with no agent selected
+            "selected_agent_name": None,  # Form starts with no agent selected
         },
     )
 
@@ -69,7 +82,9 @@ async def htmx_get_execution_form_content(
 async def htmx_get_agent_input_form(
     request: Request,
     agent_name: str,
-    current_flock: "Flock" = Depends(get_flock_instance) # Expect flock to be loaded
+    current_flock: "Flock" = Depends(
+        get_flock_instance
+    ),  # Expect flock to be loaded
 ):
     # flock instance is injected
     agent = current_flock.agents.get(agent_name)
@@ -88,12 +103,21 @@ async def htmx_get_agent_input_form(
                     "type": type_str.lower(),
                     "description": description or "",
                 }
-                if "bool" in field_info["type"]: field_info["html_type"] = "checkbox"
-                elif "int" in field_info["type"] or "float" in field_info["type"]: field_info["html_type"] = "number"
-                elif "list" in field_info["type"] or "dict" in field_info["type"]:
+                if "bool" in field_info["type"]:
+                    field_info["html_type"] = "checkbox"
+                elif (
+                    "int" in field_info["type"] or "float" in field_info["type"]
+                ):
+                    field_info["html_type"] = "number"
+                elif (
+                    "list" in field_info["type"] or "dict" in field_info["type"]
+                ):
                     field_info["html_type"] = "textarea"
-                    field_info["placeholder"] = f"Enter JSON for {field_info['type']}"
-                else: field_info["html_type"] = "text"
+                    field_info["placeholder"] = (
+                        f"Enter JSON for {field_info['type']}"
+                    )
+                else:
+                    field_info["html_type"] = "text"
                 input_fields.append(field_info)
         except Exception as e:
             return HTMLResponse(
@@ -109,7 +133,9 @@ async def htmx_get_agent_input_form(
 async def htmx_run_flock(
     request: Request,
 ):
-    current_flock_from_state: Flock | None = getattr(request.app.state, 'flock_instance', None)
+    current_flock_from_state: Flock | None = getattr(
+        request.app.state, "flock_instance", None
+    )
     logger = get_flock_logger("webapp.execution.regular_run")
 
     if not current_flock_from_state:
@@ -125,7 +151,9 @@ async def htmx_run_flock(
 
     agent = current_flock_from_state.agents.get(start_agent_name)
     if not agent:
-        logger.error(f"HTMX Run (Regular): Agent '{start_agent_name}' not found in Flock '{current_flock_from_state.name}'.")
+        logger.error(
+            f"HTMX Run (Regular): Agent '{start_agent_name}' not found in Flock '{current_flock_from_state.name}'."
+        )
         return HTMLResponse(
             f"<p class='error'>Agent '{start_agent_name}' not found in the current Flock.</p>"
         )
@@ -137,30 +165,57 @@ async def htmx_run_flock(
             for name, type_str, _ in parsed_spec:
                 form_field_name = f"agent_input_{name}"
                 raw_value = form_data.get(form_field_name)
-                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)
-                elif "float" in type_str.lower(): inputs[name] = float(raw_value)
-                elif "bool" in type_str.lower(): inputs[name] = raw_value.lower() in ["true", "on", "1", "yes"]
-                elif "list" in type_str.lower() or "dict" in type_str.lower(): inputs[name] = json.loads(raw_value)
-                else: inputs[name] = raw_value
+                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)
+                elif "float" in type_str.lower():
+                    inputs[name] = float(raw_value)
+                elif "bool" in type_str.lower():
+                    inputs[name] = raw_value.lower() in [
+                        "true",
+                        "on",
+                        "1",
+                        "yes",
+                    ]
+                elif "list" in type_str.lower() or "dict" in type_str.lower():
+                    inputs[name] = json.loads(raw_value)
+                else:
+                    inputs[name] = raw_value
         except ValueError as ve:
-            logger.error(f"HTMX Run (Regular): Input parsing error for agent '{start_agent_name}': {ve}", exc_info=True)
-            return HTMLResponse(f"<p class='error'>Invalid input format: {ve!s}</p>")
+            logger.error(
+                f"HTMX Run (Regular): Input parsing error for agent '{start_agent_name}': {ve}",
+                exc_info=True,
+            )
+            return HTMLResponse(
+                "<p class='error'>Invalid input format. Please check your input and try again.</p>"
+            )
         except Exception as e_parse:
-            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>")
-
-    result_data = await run_current_flock_service(start_agent_name, inputs, request.app.state)
+            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 {html.escape(str(start_agent_name))}: {html.escape(str(e_parse))}</p>"
+            )
 
+    result_data = await run_current_flock_service(
+        start_agent_name, inputs, request.app.state
+    )
 
     raw_json_for_template = json.dumps(
-        jsonable_encoder(result_data),   # ← converts every nested BaseModel, datetime, etc.
+        jsonable_encoder(
+            result_data
+        ),  # ← converts every nested BaseModel, datetime, etc.
         indent=2,
-        ensure_ascii=False
+        ensure_ascii=False,
     )
     # Unescape newlines for proper display in HTML <pre> tag
-    result_data_raw_json_str = raw_json_for_template.replace('\\n', '\n')
+    result_data_raw_json_str = raw_json_for_template.replace("\\n", "\n")
     root_path = request.scope.get("root_path", "")
     return templates.TemplateResponse(
         "partials/_results_display.html",
@@ -173,7 +228,7 @@ async def htmx_run_flock(
             "flock_name": current_flock_from_state.name,
             "agent_name": start_agent_name,
             "flock_definition": current_flock_from_state.to_yaml(),
-        }
+        },
     )
 
 
@@ -189,54 +244,98 @@ async def htmx_run_shared_flock(
 
     if not start_agent_name:
         shared_logger.warning("HTMX Run Shared: Starting agent not selected.")
-        return HTMLResponse("<p class='error'>Starting agent not selected for shared run.</p>")
+        return HTMLResponse(
+            "<p class='error'>Starting agent not selected for shared run.</p>"
+        )
 
     inputs: dict[str, Any] = {}
     try:
-        shared_flocks_store = getattr(request.app.state, 'shared_flocks', {})
+        shared_flocks_store = getattr(request.app.state, "shared_flocks", {})
         temp_flock = shared_flocks_store.get(share_id)
 
         if not temp_flock:
-            shared_logger.error(f"HTMX Run Shared: Flock instance for share_id '{share_id}' not found in app.state.")
-            return HTMLResponse(f"<p class='error'>Shared session not found or expired. Please try accessing the shared link again.</p>")
+            shared_logger.error(
+                f"HTMX Run Shared: Flock instance for share_id '{share_id}' not found in app.state."
+            )
+            return HTMLResponse(
+                f"<p class='error'>Shared session not found or expired. Please try accessing the shared link again.</p>"
+            )
 
-        shared_logger.info(f"HTMX Run Shared: Successfully retrieved pre-loaded Flock '{temp_flock.name}' for agent '{start_agent_name}' (share_id: {share_id}).")
+        shared_logger.info(
+            f"HTMX Run Shared: Successfully retrieved pre-loaded Flock '{temp_flock.name}' for agent '{start_agent_name}' (share_id: {share_id})."
+        )
 
         agent = temp_flock.agents.get(start_agent_name)
         if not agent:
-            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>")
+            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>"
+            )
 
         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}"
                 raw_value = form_data.get(form_field_name)
-                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)
-                elif "float" in type_str.lower(): inputs[name] = float(raw_value)
-                elif "bool" in type_str.lower(): inputs[name] = raw_value.lower() in ["true", "on", "1", "yes"]
-                elif "list" in type_str.lower() or "dict" in type_str.lower(): inputs[name] = json.loads(raw_value)
-                else: inputs[name] = raw_value
-
-        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)
+                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)
+                elif "float" in type_str.lower():
+                    inputs[name] = float(raw_value)
+                elif "bool" in type_str.lower():
+                    inputs[name] = raw_value.lower() in [
+                        "true",
+                        "on",
+                        "1",
+                        "yes",
+                    ]
+                elif "list" in type_str.lower() or "dict" in type_str.lower():
+                    inputs[name] = json.loads(raw_value)
+                else:
+                    inputs[name] = raw_value
+
+        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(
-            jsonable_encoder(result_data),   # ← converts every nested BaseModel, datetime, etc.
+            jsonable_encoder(
+                result_data
+            ),  # ← converts every nested BaseModel, datetime, etc.
             indent=2,
-            ensure_ascii=False
+            ensure_ascii=False,
         )
         # Unescape newlines for proper display in HTML <pre> tag
-        result_data_raw_json_str = raw_json_for_template.replace('\\n', '\n')
-        shared_logger.info(f"HTMX Run Shared: Agent '{start_agent_name}' executed. Result keys: {list(result_data.keys()) if isinstance(result_data, dict) else 'N/A'}")
+        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'}"
+        )
 
     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>")
+        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:
-        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>")
+        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>"
+        )
     root_path = request.scope.get("root_path", "")
 
     return templates.TemplateResponse(
@@ -250,9 +349,10 @@ async def htmx_run_shared_flock(
             "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(
@@ -292,6 +392,8 @@ async def htmx_submit_feedback_shared(
     expected_response: str | None = Form(None),
     actual_response: str | None = Form(None),
     flock_definition: str | None = Form(None),
+    flock_name: str | None = Form(None),
+    agent_name: str | None = Form(None),
     store: SharedLinkStoreInterface = Depends(get_shared_link_store),
 ):
     from uuid import uuid4
@@ -306,6 +408,94 @@ async def htmx_submit_feedback_shared(
         expected_response=expected_response,
         actual_response=actual_response,
         flock_definition=flock_definition,
+        agent_name=agent_name,
+        flock_name=flock_name,
     )
     await store.save_feedback(record)
-    return HTMLResponse("<p>🙏 Feedback received for shared run – thank you!</p>")
+    return HTMLResponse(
+        "<p>🙏 Feedback received for shared run – thank you!</p>"
+    )
+
+
+@router.get("/htmx/feedback-download/{format}", response_class=FileResponse)
+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 in the current flock as a CSV file.
+
+    This function iterates through all agents in the currently loaded flock and collects
+    all feedback records for each agent, then exports them as a single CSV file.
+
+    Args:
+        request: The FastAPI request object
+        store: The shared link store interface dependency
+
+    Returns:
+        FileResponse: CSV/XLSX file containing all feedback records for all agents
+
+    Raises:
+        HTTPException: If no flock is loaded or no agents are found in the flock
+    """
+    safe_format = secure_filename(format)
+    if safe_format == "csv":
+        return await create_csv_feedback_file(
+            request=request,
+            store=store,
+            separator=","
+        )
+    elif safe_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("/htmx/feedback-download/{agent_name}/{format}", response_class=FileResponse)
+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.
+
+    Args:
+        request: The FastAPI request object
+        agent_name: Name of the agent to download feedback for
+        store: The shared link store interface dependency
+        format: Either 'csv' or 'xlsx' the file format to use
+
+    Returns:
+        FileResponse: CSV/XLSX file containing all feedback records for the specified agent
+    """
+    safe_format = secure_filename(format)
+    safe_agent_name = secure_filename(agent_name)
+    if safe_format == "csv":
+        return await create_csv_feedback_file_for_agent(
+            request=request,
+            store=store,
+            separator=",",
+            agent_name=safe_agent_name,
+        )
+    elif safe_format == "xlsx":
+        return await create_xlsx_feedback_file_for_agent(
+            request=request,
+            store=store,
+            agent_name=safe_agent_name,
+        )
+    else:
+        from fastapi import HTTPException
+
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid file-format specified. Valid formats are: 'csv', 'xlsx'"
+        )

flock/webapp/app/chat.py

@@ -3,17 +3,24 @@ 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 HTMLResponse
+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,
@@ -572,7 +579,6 @@ async def chat_feedback(request: Request,
     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(...),
@@ -602,3 +608,58 @@ async def chat_feedback_shared(request: Request,
     }
     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'"
+        )