agent-starter-pack 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

src/cli/utils/template.py

@@ -34,9 +34,6 @@ from .remote_template import (
     render_and_merge_makefiles,
 )
 
-ADK_FILES = ["app/__init__.py"]
-NON_ADK_FILES: list[str] = []
-
 
 @dataclass
 class TemplateConfig:
@@ -72,7 +69,11 @@ class TemplateConfig:
             raise ValueError(f"Error loading template config: {err}") from err
 
 
-OVERWRITE_FOLDERS = ["app", "frontend", "tests", "notebooks"]
+def get_overwrite_folders(agent_directory: str) -> list[str]:
+    """Get folders to overwrite with configurable agent directory."""
+    return [agent_directory, "frontend", "tests", "notebooks"]
+
+
 TEMPLATE_CONFIG_FILE = "templateconfig.yaml"
 DEPLOYMENT_FOLDERS = ["cloud_run", "agent_engine"]
 DEFAULT_FRONTEND = "streamlit"
@@ -446,6 +447,7 @@ def process_template(
     remote_template_path: pathlib.Path | None = None,
     remote_config: dict[str, Any] | None = None,
     in_folder: bool = False,
+    cli_overrides: dict[str, Any] | None = None,
 ) -> None:
     """Process the template directory and create a new project.
 
@@ -462,12 +464,25 @@ def process_template(
         remote_template_path: Optional path to remote template for overlay
         remote_config: Optional remote template configuration
         in_folder: Whether to template directly into the output directory instead of creating a subdirectory
+        cli_overrides: Optional CLI override values that should take precedence over template config
     """
     logging.debug(f"Processing template from {template_dir}")
     logging.debug(f"Project name: {project_name}")
     logging.debug(f"Include pipeline: {datastore}")
     logging.debug(f"Output directory: {output_dir}")
 
+    def get_agent_directory(
+        template_config: dict[str, Any], cli_overrides: dict[str, Any] | None = None
+    ) -> str:
+        """Get agent directory with CLI override support."""
+        if (
+            cli_overrides
+            and "settings" in cli_overrides
+            and "agent_directory" in cli_overrides["settings"]
+        ):
+            return cli_overrides["settings"]["agent_directory"]
+        return template_config.get("settings", {}).get("agent_directory", "app")
+
     # Handle remote vs local templates
     is_remote = remote_template_path is not None
 
@@ -519,7 +534,21 @@ def process_template(
             base_template_path = (
                 pathlib.Path(__file__).parent.parent.parent / "base_template"
             )
-            copy_files(base_template_path, project_template, agent_name, overwrite=True)
+            # Get agent directory from config early for use in file copying
+            # Load config early to get agent_directory
+            if is_remote:
+                early_config = remote_config or {}
+            else:
+                template_path = pathlib.Path(template_dir)
+                early_config = load_template_config(template_path)
+            agent_directory = get_agent_directory(early_config, cli_overrides)
+            copy_files(
+                base_template_path,
+                project_template,
+                agent_name,
+                overwrite=True,
+                agent_directory=agent_directory,
+            )
             logging.debug(f"1. Copied base template from {base_template_path}")
 
             # 2. Process deployment target if specified
@@ -535,6 +564,7 @@ def process_template(
                         project_template,
                         agent_name=agent_name,
                         overwrite=True,
+                        agent_directory=agent_directory,
                     )
                     logging.debug(
                         f"2. Processed deployment files for target: {deployment_target}"
@@ -556,27 +586,11 @@ def process_template(
             copy_frontend_files(frontend_type, project_template)
             logging.debug(f"4. Processed frontend files for type: {frontend_type}")
 
-            # 5. Copy agent-specific files to override base template
-            if agent_path.exists():
-                for folder in OVERWRITE_FOLDERS:
-                    agent_folder = agent_path / folder
-                    project_folder = project_template / folder
-                    if agent_folder.exists():
-                        logging.debug(f"5. Copying agent folder {folder} with override")
-                        copy_files(
-                            agent_folder, project_folder, agent_name, overwrite=True
-                        )
-
-            # 6. Finally, overlay remote template files if present
+            # 6. Skip remote template files during cookiecutter processing
+            # Remote files will be copied after cookiecutter to avoid Jinja conflicts
             if is_remote and remote_template_path:
                 logging.debug(
-                    f"6. Overlaying remote template files from {remote_template_path}"
-                )
-                copy_files(
-                    remote_template_path,
-                    project_template,
-                    agent_name=agent_name,
-                    overwrite=True,
+                    "6. Skipping remote template files during cookiecutter processing - will copy after templating"
                 )
 
             # Load and validate template config first
@@ -602,6 +616,45 @@ def process_template(
             # Use the already loaded config
             template_config = config
 
+            # 5. Copy agent-specific files to override base template (using final config)
+            if agent_path.exists():
+                agent_directory = get_agent_directory(template_config, cli_overrides)
+
+                # Get the template's default agent directory (usually "app")
+                template_agent_directory = template_config.get("settings", {}).get(
+                    "agent_directory", "app"
+                )
+
+                # Copy agent directory (always from "app" to target directory)
+                source_agent_folder = agent_path / template_agent_directory
+                target_agent_folder = project_template / agent_directory
+                if source_agent_folder.exists():
+                    logging.debug(
+                        f"5. Copying agent folder {template_agent_directory} -> {agent_directory} with override"
+                    )
+                    copy_files(
+                        source_agent_folder,
+                        target_agent_folder,
+                        agent_name,
+                        overwrite=True,
+                        agent_directory=agent_directory,
+                    )
+
+                # Copy other folders (frontend, tests, notebooks)
+                other_folders = ["frontend", "tests", "notebooks"]
+                for folder in other_folders:
+                    agent_folder = agent_path / folder
+                    project_folder = project_template / folder
+                    if agent_folder.exists():
+                        logging.debug(f"5. Copying {folder} folder with override")
+                        copy_files(
+                            agent_folder,
+                            project_folder,
+                            agent_name,
+                            overwrite=True,
+                            agent_directory=agent_directory,
+                        )
+
             # Check if data processing should be included
             if include_data_ingestion and datastore:
                 logging.debug(
@@ -649,6 +702,7 @@ def process_template(
                 "extra_dependencies": [extra_deps],
                 "data_ingestion": include_data_ingestion,
                 "datastore_type": datastore if datastore else "",
+                "agent_directory": get_agent_directory(template_config, cli_overrides),
                 "adk_cheatsheet": adk_cheatsheet_content,
                 "llm_txt": llm_txt_content,
                 "_copy_without_render": [
@@ -664,7 +718,9 @@ def process_template(
                     "*templates.py",  # Don't render templates files
                     "Makefile",  # Don't render Makefile - handled by render_and_merge_makefiles
                     # Don't render agent.py unless it's agentic_rag
-                    "app/agent.py" if agent_name != "agentic_rag" else "",
+                    f"{get_agent_directory(template_config, cli_overrides)}/agent.py"
+                    if agent_name != "agentic_rag"
+                    else "",
                 ],
             }
 
@@ -690,6 +746,21 @@ def process_template(
             )
             logging.debug("Template processing completed successfully")
 
+            # Now overlay remote template files if present (after cookiecutter processing)
+            if is_remote and remote_template_path:
+                generated_project_dir = temp_path / project_name
+                logging.debug(
+                    f"Copying remote template files from {remote_template_path} to {generated_project_dir}"
+                )
+                copy_files(
+                    remote_template_path,
+                    generated_project_dir,
+                    agent_name=agent_name,
+                    overwrite=True,
+                    agent_directory=agent_directory,
+                )
+                logging.debug("Remote template files copied successfully")
+
             # Move the generated project to the final destination
             generated_project_dir = temp_path / project_name
 
@@ -842,15 +913,7 @@ def process_template(
             )
 
             # Delete appropriate files based on ADK tag
-            if "adk" in tags:
-                files_to_delete = [final_destination / f for f in NON_ADK_FILES]
-            else:
-                files_to_delete = [final_destination / f for f in ADK_FILES]
-
-            for file_path in files_to_delete:
-                if file_path.exists():
-                    file_path.unlink()
-                    logging.debug(f"Deleted {file_path}")
+            agent_directory = get_agent_directory(template_config, cli_overrides)
 
             # Clean up unused_* files and directories created by conditional templates
             import glob
@@ -923,11 +986,15 @@ def process_template(
             os.chdir(original_dir)
 
 
-def should_exclude_path(path: pathlib.Path, agent_name: str) -> bool:
+def should_exclude_path(
+    path: pathlib.Path, agent_name: str, agent_directory: str = "app"
+) -> bool:
     """Determine if a path should be excluded based on the agent type."""
     if agent_name == "live_api":
-        # Exclude the unit test utils folder and app/utils folder for live_api
-        if "tests/unit/test_utils" in str(path) or "app/utils" in str(path):
+        # Exclude the unit test utils folder and agent utils folder for live_api
+        if "tests/unit/test_utils" in str(path) or f"{agent_directory}/utils" in str(
+            path
+        ):
             logging.debug(f"Excluding path for live_api: {path}")
             return True
     return False
@@ -938,6 +1005,7 @@ def copy_files(
     dst: pathlib.Path,
     agent_name: str | None = None,
     overwrite: bool = False,
+    agent_directory: str = "app",
 ) -> None:
     """
     Copy files with configurable behavior for exclusions and overwrites.
@@ -947,6 +1015,7 @@ def copy_files(
         dst: Destination path
         agent_name: Name of the agent (for agent-specific exclusions)
         overwrite: Whether to overwrite existing files (True) or skip them (False)
+        agent_directory: Name of the agent directory (for agent-specific exclusions)
     """
 
     def should_skip(path: pathlib.Path) -> bool:
@@ -957,7 +1026,9 @@ def copy_files(
             return True
         if ".git" in path.parts:
             return True
-        if agent_name is not None and should_exclude_path(path, agent_name):
+        if agent_name is not None and should_exclude_path(
+            path, agent_name, agent_directory
+        ):
             return True
         if path.is_dir() and path.name == ".template":
             return True
@@ -970,9 +1041,10 @@ def copy_files(
             if should_skip(item):
                 logging.debug(f"Skipping file/directory: {item}")
                 continue
+
             d = dst / item.name
             if item.is_dir():
-                copy_files(item, d, agent_name, overwrite)
+                copy_files(item, d, agent_name, overwrite, agent_directory)
             else:
                 if overwrite or not d.exists():
                     logging.debug(f"Copying file: {item} -> {d}")
@@ -1012,7 +1084,10 @@ def copy_frontend_files(frontend_type: str, project_template: pathlib.Path) -> N
 
 
 def copy_deployment_files(
-    deployment_target: str, agent_name: str, project_template: pathlib.Path
+    deployment_target: str,
+    agent_name: str,
+    project_template: pathlib.Path,
+    agent_directory: str = "app",
 ) -> None:
     """Copy files from the specified deployment target folder."""
     if not deployment_target:
@@ -1028,7 +1103,11 @@ def copy_deployment_files(
         logging.debug(f"Copying deployment files from {deployment_path}")
         # Pass agent_name to respect agent-specific exclusions
         copy_files(
-            deployment_path, project_template, agent_name=agent_name, overwrite=True
+            deployment_path,
+            project_template,
+            agent_name=agent_name,
+            overwrite=True,
+            agent_directory=agent_directory,
         )
     else:
         logging.warning(f"Deployment target directory not found: {deployment_path}")

src/deployment_targets/agent_engine/tests/integration/test_agent_engine_app.py

@@ -18,11 +18,11 @@ import pytest
 {%- if "adk" in cookiecutter.tags %}
 from google.adk.events.event import Event
 
-from app.agent import root_agent
-from app.agent_engine_app import AgentEngineApp
+from {{cookiecutter.agent_directory}}.agent import root_agent
+from {{cookiecutter.agent_directory}}.agent_engine_app import AgentEngineApp
 {%- else %}
 
-from app.agent_engine_app import AgentEngineApp
+from {{cookiecutter.agent_directory}}.agent_engine_app import AgentEngineApp
 {%- endif %}
 
 

src/deployment_targets/agent_engine/{app → {{cookiecutter.agent_directory}}}/agent_engine_app.py

@@ -30,10 +30,10 @@ from opentelemetry.sdk.trace import TracerProvider, export
 from vertexai import agent_engines
 from vertexai.preview.reasoning_engines import AdkApp
 
-from app.agent import root_agent
-from app.utils.gcs import create_bucket_if_not_exists
-from app.utils.tracing import CloudTraceLoggingSpanExporter
-from app.utils.typing import Feedback
+from {{cookiecutter.agent_directory}}.agent import root_agent
+from {{cookiecutter.agent_directory}}.utils.gcs import create_bucket_if_not_exists
+from {{cookiecutter.agent_directory}}.utils.tracing import CloudTraceLoggingSpanExporter
+from {{cookiecutter.agent_directory}}.utils.typing import Feedback
 
 
 class AgentEngineApp(AdkApp):
@@ -95,9 +95,9 @@ from langchain_core.runnables import RunnableConfig
 from traceloop.sdk import Instruments, Traceloop
 from vertexai import agent_engines
 
-from app.utils.gcs import create_bucket_if_not_exists
-from app.utils.tracing import CloudTraceLoggingSpanExporter
-from app.utils.typing import Feedback, InputChat, dumpd, ensure_valid_config
+from {{cookiecutter.agent_directory}}.utils.gcs import create_bucket_if_not_exists
+from {{cookiecutter.agent_directory}}.utils.tracing import CloudTraceLoggingSpanExporter
+from {{cookiecutter.agent_directory}}.utils.typing import Feedback, InputChat, dumpd, ensure_valid_config
 
 
 class AgentEngineApp:
@@ -110,7 +110,7 @@ class AgentEngineApp:
     def set_up(self) -> None:
         """The set_up method is used to define application initialization logic"""
         # Lazy import agent at setup time to avoid deployment dependencies
-        from app.agent import agent
+        from {{cookiecutter.agent_directory}}.agent import agent
 
         logging_client = google_cloud_logging.Client(project=self.project_id)
         self.logger = logging_client.logger(__name__)
@@ -206,7 +206,7 @@ def deploy_agent_engine_app(
     location: str,
     agent_name: str | None = None,
     requirements_file: str = ".requirements.txt",
-    extra_packages: list[str] = ["./app"],
+    extra_packages: list[str] = ["./{{cookiecutter.agent_directory}}"],
     env_vars: dict[str, str] = {},
     service_account: str | None = None,
 ) -> agent_engines.AgentEngine:
@@ -305,7 +305,7 @@ if __name__ == "__main__":
     parser.add_argument(
         "--extra-packages",
         nargs="+",
-        default=["./app"],
+        default=["./{{cookiecutter.agent_directory}}"],
         help="Additional packages to include",
     )
     parser.add_argument(

src/deployment_targets/cloud_run/Dockerfile

@@ -20,7 +20,7 @@ WORKDIR /code
 
 COPY ./pyproject.toml ./README.md ./uv.lock* ./
 
-COPY ./app ./app
+COPY ./{{cookiecutter.agent_directory}} ./{{cookiecutter.agent_directory}}
 
 RUN uv sync --frozen
 
@@ -29,4 +29,4 @@ ENV COMMIT_SHA=${COMMIT_SHA}
 
 EXPOSE 8080
 
-CMD ["uv", "run", "uvicorn", "app.server:app", "--host", "0.0.0.0", "--port", "8080"]
+CMD ["uv", "run", "uvicorn", "{{cookiecutter.agent_directory}}.server:app", "--host", "0.0.0.0", "--port", "8080"]

src/deployment_targets/cloud_run/tests/integration/test_server_e2e.py

@@ -54,7 +54,7 @@ def start_server() -> subprocess.Popen[str]:
         sys.executable,
         "-m",
         "uvicorn",
-        "app.server:app",
+        "{{cookiecutter.agent_directory}}.server:app",
         "--host",
         "0.0.0.0",
         "--port",
@@ -129,7 +129,7 @@ def test_chat_stream(server_fixture: subprocess.Popen[str]) -> None:
     user_id = "test_user_123"
     session_data = {"state": {"preferred_language": "English", "visit_count": 1}}
 
-    session_url = f"{BASE_URL}/apps/app/users/{user_id}/sessions"
+    session_url = f"{BASE_URL}/apps/{{cookiecutter.agent_directory}}/users/{user_id}/sessions"
     session_response = requests.post(
         session_url,
         headers=HEADERS,
@@ -142,7 +142,7 @@ def test_chat_stream(server_fixture: subprocess.Popen[str]) -> None:
 
     # Then send chat message
     data = {
-        "app_name": "app",
+        "app_name": "{{cookiecutter.agent_directory}}",
         "user_id": user_id,
         "session_id": session_id,
         "new_message": {

src/deployment_targets/cloud_run/tests/load_test/README.md

@@ -11,7 +11,7 @@ Follow these steps to execute load tests on your local machine:
 Launch the FastAPI server in a separate terminal:
 
 ```bash
-uv run uvicorn app.server:app --host 0.0.0.0 --port 8000 --reload
+uv run uvicorn {{cookiecutter.agent_directory}}.server:app --host 0.0.0.0 --port 8000 --reload
 ```
 
 **2. (In another tab) Create virtual environment with Locust**

src/deployment_targets/cloud_run/tests/load_test/load_test.py

@@ -45,7 +45,7 @@ class ChatStreamUser(HttpUser):
         user_id = f"user_{uuid.uuid4()}"
         session_data = {"state": {"preferred_language": "English", "visit_count": 1}}
 
-        session_url = f"{self.client.base_url}/apps/app/users/{user_id}/sessions"
+        session_url = f"{self.client.base_url}/apps/{{cookiecutter.agent_directory}}/users/{user_id}/sessions"
         session_response = requests.post(
             session_url,
             headers=headers,
@@ -58,7 +58,7 @@ class ChatStreamUser(HttpUser):
 
         # Send chat message
         data = {
-            "app_name": "app",
+            "app_name": "{{cookiecutter.agent_directory}}",
             "user_id": user_id,
             "session_id": session_id,
             "new_message": {

{agents/live_api/app → src/deployment_targets/cloud_run/{{cookiecutter.agent_directory}}}/server.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+{% if cookiecutter.agent_name == "live_api" %}
 import asyncio
 import json
 import logging
@@ -27,7 +27,7 @@ from google.genai.types import LiveServerToolCall
 from pydantic import BaseModel
 from websockets.exceptions import ConnectionClosedError
 
-from app.agent import MODEL_ID, genai_client, live_connect_config, tool_functions
+from .agent import MODEL_ID, genai_client, live_connect_config, tool_functions
 
 app = FastAPI()
 app.add_middleware(
@@ -197,16 +197,195 @@ class Feedback(BaseModel):
     run_id: str
     user_id: str | None
     log_type: Literal["feedback"] = "feedback"
+{% elif "adk" in cookiecutter.tags %}
+import os
+
+import google.auth
+from fastapi import FastAPI
+from google.adk.cli.fast_api import get_fast_api_app
+from google.cloud import logging as google_cloud_logging
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider, export
+{%- if cookiecutter.session_type == "agent_engine" %}
+from vertexai import agent_engines
+{%- endif %}
+
+from {{cookiecutter.agent_directory}}.utils.gcs import create_bucket_if_not_exists
+from {{cookiecutter.agent_directory}}.utils.tracing import CloudTraceLoggingSpanExporter
+from {{cookiecutter.agent_directory}}.utils.typing import Feedback
 
+_, project_id = google.auth.default()
+logging_client = google_cloud_logging.Client()
+logger = logging_client.logger(__name__)
+allow_origins = (
+    os.getenv("ALLOW_ORIGINS", "").split(",") if os.getenv("ALLOW_ORIGINS") else None
+)
+
+bucket_name = f"gs://{project_id}-{{cookiecutter.project_name}}-logs-data"
+create_bucket_if_not_exists(
+    bucket_name=bucket_name, project=project_id, location="us-central1"
+)
+
+provider = TracerProvider()
+processor = export.BatchSpanProcessor(CloudTraceLoggingSpanExporter())
+provider.add_span_processor(processor)
+trace.set_tracer_provider(provider)
+
+AGENT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+{%- if cookiecutter.session_type == "alloydb" %}
+# AlloyDB session configuration
+db_user = os.environ.get("DB_USER", "postgres")
+db_name = os.environ.get("DB_NAME", "postgres")
+db_pass = os.environ.get("DB_PASS")
+db_host = os.environ.get("DB_HOST")
+
+# Set session_service_uri if database credentials are available
+session_service_uri = None
+if db_host and db_pass:
+    session_service_uri = f"postgresql://{db_user}:{db_pass}@{db_host}:5432/{db_name}"
+{%- elif cookiecutter.session_type == "agent_engine" %}
+# Agent Engine session configuration
+# Use environment variable for agent name, default to project name
+agent_name = os.environ.get("AGENT_ENGINE_SESSION_NAME", "{{cookiecutter.project_name}}")
+
+# Check if an agent with this name already exists
+existing_agents = list(agent_engines.list(filter=f"display_name={agent_name}"))
+
+if existing_agents:
+    # Use the existing agent
+    agent_engine = existing_agents[0]
+else:
+    # Create a new agent if none exists
+    agent_engine = agent_engines.create(display_name=agent_name)
+
+session_service_uri = f"agentengine://{agent_engine.resource_name}"
+{%- else %}
+# In-memory session configuration - no persistent storage
+session_service_uri = None
+{%- endif %}
+
+app: FastAPI = get_fast_api_app(
+    agents_dir=AGENT_DIR,
+    web=True,
+    artifact_service_uri=bucket_name,
+    allow_origins=allow_origins,
+    session_service_uri=session_service_uri,
+)
+app.title = "{{cookiecutter.project_name}}"
+app.description = "API for interacting with the Agent {{cookiecutter.project_name}}"
+{% else %}
+import logging
+import os
+from collections.abc import Generator
+
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse, StreamingResponse
+from google.cloud import logging as google_cloud_logging
+from langchain_core.runnables import RunnableConfig
+from traceloop.sdk import Instruments, Traceloop
+
+from {{cookiecutter.agent_directory}}.agent import agent
+from {{cookiecutter.agent_directory}}.utils.tracing import CloudTraceLoggingSpanExporter
+from {{cookiecutter.agent_directory}}.utils.typing import Feedback, InputChat, Request, dumps, ensure_valid_config
+
+# Initialize FastAPI app and logging
+app = FastAPI(
+    title="{{cookiecutter.project_name}}",
+    description="API for interacting with the Agent {{cookiecutter.project_name}}",
+)
+logging_client = google_cloud_logging.Client()
+logger = logging_client.logger(__name__)
+
+# Initialize Telemetry
+try:
+    Traceloop.init(
+        app_name=app.title,
+        disable_batch=False,
+        exporter=CloudTraceLoggingSpanExporter(),
+        instruments={Instruments.LANGCHAIN, Instruments.CREW},
+    )
+except Exception as e:
+    logging.error("Failed to initialize Telemetry: %s", str(e))
+
+
+def set_tracing_properties(config: RunnableConfig) -> None:
+    """Sets tracing association properties for the current request.
+
+    Args:
+        config: Optional RunnableConfig containing request metadata
+    """
+    Traceloop.set_association_properties(
+        {
+            "log_type": "tracing",
+            "run_id": str(config.get("run_id", "None")),
+            "user_id": config["metadata"].pop("user_id", "None"),
+            "session_id": config["metadata"].pop("session_id", "None"),
+            "commit_sha": os.environ.get("COMMIT_SHA", "None"),
+        }
+    )
+
+
+def stream_messages(
+    input: InputChat,
+    config: RunnableConfig | None = None,
+) -> Generator[str, None, None]:
+    """Stream events in response to an input chat.
+
+    Args:
+        input: The input chat messages
+        config: Optional configuration for the runnable
+
+    Yields:
+        JSON serialized event data
+    """
+    config = ensure_valid_config(config=config)
+    set_tracing_properties(config)
+    input_dict = input.model_dump()
+
+    for data in agent.stream(input_dict, config=config, stream_mode="messages"):  # type: ignore[arg-type]
+        yield dumps(data) + "\n"
+
+
+# Routes
+@app.get("/", response_class=RedirectResponse)
+def redirect_root_to_docs() -> RedirectResponse:
+    """Redirect the root URL to the API documentation."""
+    return RedirectResponse(url="/docs")
+
+
+@app.post("/stream_messages")
+def stream_chat_events(request: Request) -> StreamingResponse:
+    """Stream chat events in response to an input request.
+
+    Args:
+        request: The chat request containing input and config
+
+    Returns:
+        Streaming response of chat events
+    """
+    return StreamingResponse(
+        stream_messages(input=request.input, config=request.config),
+        media_type="text/event-stream",
+    )
+{% endif %}
 
 @app.post("/feedback")
-async def collect_feedback(feedback_dict: Feedback) -> None:
-    """Collect and log feedback."""
-    feedback_data = feedback_dict.model_dump()
-    logger.log_struct(feedback_data, severity="INFO")
+def collect_feedback(feedback: Feedback) -> dict[str, str]:
+    """Collect and log feedback.
+
+    Args:
+        feedback: The feedback data to log
+
+    Returns:
+        Success message
+    """
+    logger.log_struct(feedback.model_dump(), severity="INFO")
+    return {"status": "success"}
 
 
+# Main execution
 if __name__ == "__main__":
     import uvicorn
 
-    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="debug")
+    uvicorn.run(app, host="0.0.0.0", port=8000)