agent-starter-pack 0.15.7__py3-none-any.whl → 0.16.0__py3-none-any.whl

src/utils/generate_locks.py

@@ -22,7 +22,7 @@ import subprocess
 import tempfile
 
 import click
-from jinja2 import Template
+from jinja2 import StrictUndefined, Template
 from lock_utils import get_agent_configs, get_lock_filename
 
 
@@ -55,15 +55,19 @@ def generate_pyproject(
         extra_dependencies: List of additional dependencies from .templateconfig.yaml
     """
     with open(template_path, encoding="utf-8") as f:
-        template = Template(f.read(), trim_blocks=True, lstrip_blocks=True)
+        template = Template(f.read(), trim_blocks=True, lstrip_blocks=True, undefined=StrictUndefined)
 
     # Convert list to proper format for template
+    tags = list(config.get("tags", []))
     context = {
         "cookiecutter": {
             "project_name": "locked-template",
             "deployment_target": deployment_target,
-            "extra_dependencies": list(config.get("extra_dependencies",[])),
-            "tags": list(config.get("tags",[])),
+            "extra_dependencies": list(config.get("extra_dependencies", [])),
+            "tags": tags,
+            "is_adk": "adk" in tags,
+            "is_adk_live": "adk_live" in tags,
+            "agent_directory": config.get("agent_directory", "app"),
         }
     }
 

agents/live_api/README.md

@@ -1,37 +0,0 @@
-# Multimodal Live Agent
-
-This pattern showcases a real-time conversational agent powered by Google Gemini. The agent handles audio, video, and text interactions while leveraging tool calling capabilities for enhanced responses.
-
-![live_api_diagram](https://storage.googleapis.com/github-repo/generative-ai/sample-apps/e2e-gen-ai-app-starter-pack/live_api_diagram.png)
-
-**Key components:**
-
-- **Python Backend** (in `app/` folder): A production-ready server built with [FastAPI](https://fastapi.tiangolo.com/) and [google-genai](https://googleapis.github.io/python-genai/) that features:
-
-  - **Real-time bidirectional communication** via WebSockets between the frontend and Gemini model
-  - **Integrated tool calling** with a weather information tool for demonstrating external data retrieval
-  - **Production-grade reliability** with retry logic and automatic reconnection capabilities
-  - **Deployment flexibility** supporting both AI Studio and Vertex AI endpoints
-  - **Feedback logging endpoint** for collecting user interactions
-
-- **React Frontend** (in `frontend/` folder): Extends the [Multimodal live API Web Console](https://github.com/google-gemini/multimodal-live-api-web-console), with added features like **custom URLs** and **feedback collection**.
-
-![live api demo](https://storage.googleapis.com/github-repo/generative-ai/sample-apps/e2e-gen-ai-app-starter-pack/live_api_pattern_demo.gif)
-
-Once both the backend and frontend are running, click the play button in the frontend UI to establish a connection with the backend. You can now interact with the Multimodal Live Agent! You can try asking questions such as "What's the weather like in San Francisco?" to see the agent use its weather information tool.
-
-## Additional Resources for Multimodal Live API
-
-Explore these resources to learn more about the Multimodal Live API and see examples of its usage:
-
-- [Project Pastra](https://github.com/heiko-hotz/gemini-multimodal-live-dev-guide/tree/main): a comprehensive developer guide for the Gemini Multimodal Live API.
-- [Google Cloud Multimodal Live API demos and samples](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/gemini/multimodal-live-api): Collection of code samples and demo applications leveraging multimodal live API in Vertex AI
-- [Gemini 2 Cookbook](https://github.com/google-gemini/cookbook/tree/main/gemini-2): Practical examples and tutorials for working with Gemini 2
-- [Multimodal Live API Web Console](https://github.com/google-gemini/multimodal-live-api-web-console): Interactive React-based web interface for testing and experimenting with Gemini Multimodal Live API.
-
-## Current Status & Future Work
-
-This pattern is under active development. Key areas planned for future enhancement include:
-
-*   **Observability:** Implementing comprehensive monitoring and tracing features.
-*   **Load Testing:** Integrating load testing capabilities.

agents/live_api/app/agent.py

@@ -1,72 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-
-import os
-
-import google.auth
-import vertexai
-from google import genai
-from google.genai import types
-
-# Constants
-VERTEXAI = os.getenv("VERTEXAI", "true").lower() == "true"
-LOCATION = "us-central1"
-MODEL_ID = "gemini-live-2.5-flash-preview-native-audio"
-
-# Initialize Google Cloud clients
-credentials, project_id = google.auth.default()
-vertexai.init(project=project_id, location=LOCATION)
-
-
-if VERTEXAI:
-    genai_client = genai.Client(project=project_id, location=LOCATION, vertexai=True)
-else:
-    # API key should be set using GOOGLE_API_KEY environment variable
-    genai_client = genai.Client(http_options={"api_version": "v1alpha"})
-
-
-def get_weather(query: str) -> dict:
-    """Simulates a web search. Use it get information on weather.
-
-    Args:
-        query: A string containing the location to get weather information for.
-
-    Returns:
-        A string with the simulated weather information for the queried location.
-    """
-    if "sf" in query.lower() or "san francisco" in query.lower():
-        return {"output": "It's 60 degrees and foggy."}
-    return {"output": "It's 90 degrees and sunny."}
-
-
-# Configure tools available to the agent and live connection
-tool_functions = {"get_weather": get_weather}
-
-live_connect_config = types.LiveConnectConfig(
-    response_modalities=[types.Modality.AUDIO],
-    tools=list(tool_functions.values()),
-    system_instruction=types.Content(
-        parts=[
-            types.Part(
-                text="""You are a helpful AI assistant designed to provide accurate and useful information. You are able to accommodate different languages and tones of voice."""
-            )
-        ]
-    ),
-    speech_config=types.SpeechConfig(
-        voice_config=types.VoiceConfig(
-            prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name="Kore")
-        )
-    ),
-    enable_affective_dialog=True,
-)

agents/live_api/tests/integration/test_server_e2e.py

@@ -1,260 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-
-import asyncio
-import json
-import logging
-import os
-import subprocess
-import sys
-import threading
-import time
-import uuid
-from collections.abc import Iterator
-from typing import Any
-
-import pytest
-import requests
-import websockets.client
-
-# Configure logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-BASE_URL = "ws://127.0.0.1:8000/"
-WS_URL = BASE_URL + "ws"
-
-FEEDBACK_URL = "http://127.0.0.1:8000/feedback"
-HEADERS = {"Content-Type": "application/json"}
-
-
-def log_output(pipe: Any, log_func: Any) -> None:
-    """Log the output from the given pipe."""
-    for line in iter(pipe.readline, ""):
-        log_func(line.strip())
-
-
-def start_server() -> subprocess.Popen[str]:
-    """Start the FastAPI server using subprocess and log its output."""
-    command = [
-        sys.executable,
-        "-m",
-        "uvicorn",
-        "app.server:app",
-        "--host",
-        "0.0.0.0",
-        "--port",
-        "8000",
-    ]
-    env = os.environ.copy()
-    env["INTEGRATION_TEST"] = "TRUE"
-    process = subprocess.Popen(
-        command,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-        bufsize=1,
-        env=env,
-        encoding="utf-8",
-    )
-
-    # Start threads to log stdout and stderr in real-time
-    threading.Thread(
-        target=log_output, args=(process.stdout, logger.info), daemon=True
-    ).start()
-    threading.Thread(
-        target=log_output, args=(process.stderr, logger.error), daemon=True
-    ).start()
-
-    return process
-
-
-def wait_for_server(timeout: int = 60, interval: int = 1) -> bool:
-    """Wait for the server to be ready."""
-    start_time = time.time()
-    while time.time() - start_time < timeout:
-        try:
-            response = requests.get("http://127.0.0.1:8000/docs", timeout=10)
-            if response.status_code == 200:
-                logger.info("Server is ready")
-                return True
-        except Exception:
-            pass
-        time.sleep(interval)
-    logger.error(f"Server did not become ready within {timeout} seconds")
-    return False
-
-
-@pytest.fixture(scope="session")
-def server_fixture(request: Any) -> Iterator[subprocess.Popen[str]]:
-    """Pytest fixture to start and stop the server for testing."""
-    logger.info("Starting server process")
-    server_process = start_server()
-    if not wait_for_server():
-        pytest.fail("Server failed to start")
-    logger.info("Server process started")
-
-    def stop_server() -> None:
-        logger.info("Stopping server process")
-        server_process.terminate()
-        try:
-            server_process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            logger.warning("Server process did not terminate, killing it")
-            server_process.kill()
-            server_process.wait()
-        logger.info("Server process stopped")
-
-    request.addfinalizer(stop_server)
-    yield server_process
-
-
-@pytest.mark.asyncio
-async def test_websocket_connection(server_fixture: subprocess.Popen[str]) -> None:
-    """Test the websocket connection and message exchange."""
-
-    async def send_message(websocket: Any, message: dict[str, Any]) -> None:
-        """Helper function to send messages and log them."""
-        await websocket.send(json.dumps(message))
-
-    async def receive_message(websocket: Any, timeout: float = 5.0) -> dict[str, Any]:
-        """Helper function to receive messages with timeout."""
-        try:
-            response = await asyncio.wait_for(websocket.recv(), timeout=timeout)
-            if isinstance(response, bytes):
-                return json.loads(response.decode())
-            if isinstance(response, str):
-                return json.loads(response)
-            return response
-        except asyncio.TimeoutError as exc:
-            raise TimeoutError(
-                f"No response received within {timeout} seconds"
-            ) from exc
-
-    try:
-        await asyncio.sleep(2)
-
-        async with websockets.connect(
-            WS_URL, ping_timeout=10, close_timeout=10
-        ) as websocket:
-            try:
-                # Wait for initial ready message
-                initial_response = None
-                for _ in range(10):
-                    try:
-                        initial_response = await receive_message(websocket, timeout=5.0)
-                        if (
-                            initial_response is not None
-                            and initial_response.get("status")
-                            == "Backend is ready for conversation"
-                        ):
-                            break
-                    except TimeoutError:
-                        if _ == 9:
-                            raise
-                        continue
-
-                assert (
-                    initial_response is not None
-                    and initial_response.get("status")
-                    == "Backend is ready for conversation"
-                )
-
-                # Send messages
-                setup_msg = {"setup": {"run_id": "test-run", "user_id": "test-user"}}
-                await send_message(websocket, setup_msg)
-
-                dummy_audio = bytes([0] * 1024)
-                audio_msg = {
-                    "realtimeInput": {
-                        "mediaChunks": [
-                            {
-                                "mimeType": "audio/pcm;rate=16000",
-                                "data": dummy_audio.hex(),
-                            }
-                        ]
-                    }
-                }
-                await send_message(websocket, audio_msg)
-
-                text_msg = {
-                    "clientContent": {
-                        "turns": [
-                            {"role": "user", "parts": [{"text": "Hello, how are you?"}]}
-                        ],
-                        "turnComplete": True,
-                    }
-                }
-                await send_message(websocket, text_msg)
-
-                # Collect responses with timeout
-                responses = []
-                try:
-                    while True:
-                        try:
-                            response = await receive_message(websocket, timeout=10.0)
-                            responses.append(response)
-                            if (
-                                len(responses) >= 3
-                            ):  # Exit after receiving enough responses
-                                break
-                        except TimeoutError:
-                            break
-                except asyncio.TimeoutError:
-                    logger.info("Response collection timed out")
-
-                # Verify responses
-                assert len(responses) > 0, "No responses received from server"
-                assert any(
-                    isinstance(r, dict) and "serverContent" in r for r in responses
-                )
-                logger.info(
-                    f"Test completed successfully. Received {len(responses)} responses"
-                )
-
-            finally:
-                # Ensure websocket is closed properly
-                await websocket.close()
-
-    except Exception as e:
-        logger.error(f"Test failed with error: {e!s}")
-        raise
-
-    finally:
-        # Clean up any remaining tasks
-        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
-        for task in tasks:
-            task.cancel()
-        if tasks:
-            await asyncio.gather(*tasks, return_exceptions=True)
-
-
-def test_collect_feedback(server_fixture: subprocess.Popen[str]) -> None:
-    """
-    Test the feedback collection endpoint (/feedback) to ensure it properly
-    logs the received feedback.
-    """
-    # Create sample feedback data
-    feedback_data = {
-        "score": 4,
-        "text": "Great response!",
-        "run_id": str(uuid.uuid4()),
-        "user_id": "user1",
-        "log_type": "feedback",
-    }
-
-    response = requests.post(
-        FEEDBACK_URL, json=feedback_data, headers=HEADERS, timeout=10
-    )
-    assert response.status_code == 200

agents/live_api/tests/load_test/load_test.py

@@ -1,40 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-
-import time
-
-from locust import HttpUser, between, task
-
-
-class DummyUser(HttpUser):
-    """Simulates a user for testing purposes."""
-
-    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
-
-    @task
-    def dummy_task(self) -> None:
-        """A dummy task that simulates work without making actual requests."""
-        # Simulate some processing time
-        time.sleep(0.1)
-
-        # Record a successful dummy request
-        self.environment.events.request.fire(
-            request_type="POST",
-            name="dummy_endpoint",
-            response_time=100,
-            response_length=1024,
-            response=None,
-            context={},
-            exception=None,
-        )

agents/live_api/tests/unit/test_server.py

@@ -1,144 +0,0 @@
-# Copyright 2025 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-
-import json
-import logging
-import os
-from collections.abc import Generator
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-from fastapi.testclient import TestClient
-from google.auth.credentials import Credentials
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-@pytest.fixture(autouse=True)
-def mock_google_cloud_credentials() -> Generator[None, None, None]:
-    """Mock Google Cloud credentials for testing."""
-    with patch.dict(
-        os.environ,
-        {
-            "GOOGLE_APPLICATION_CREDENTIALS": "/path/to/mock/credentials.json",
-            "GOOGLE_CLOUD_PROJECT_ID": "mock-project-id",
-        },
-    ):
-        yield
-
-
-@pytest.fixture(autouse=True)
-def mock_google_auth_default() -> Generator[None, None, None]:
-    """Mock the google.auth.default function for testing."""
-    mock_credentials = MagicMock(spec=Credentials)
-    mock_project = "mock-project-id"
-
-    with patch("google.auth.default", return_value=(mock_credentials, mock_project)):
-        yield
-
-
-@pytest.fixture(autouse=True)
-def mock_dependencies() -> Generator[None, None, None]:
-    """
-    Mock Vertex AI dependencies for testing.
-    Patches genai client and tool functions.
-    """
-    with (
-        patch("{{cookiecutter.agent_directory}}.server.genai_client") as mock_genai,
-        patch("{{cookiecutter.agent_directory}}.server.tool_functions") as mock_tools,
-    ):
-        mock_genai.aio.live.connect = AsyncMock()
-        mock_tools.return_value = {}
-        yield
-
-
-@pytest.mark.asyncio
-async def test_websocket_endpoint() -> None:
-    """
-    Test the websocket endpoint to ensure it correctly handles
-    websocket connections and messages.
-    """
-    from {{cookiecutter.agent_directory}}.server import app
-
-    mock_session = AsyncMock()
-    mock_session._ws = AsyncMock()
-    # Configure mock to return proper response format and close after one message
-    mock_session._ws.recv.side_effect = [
-        json.dumps(
-            {
-                "serverContent": {
-                    "modelTurn": {
-                        "role": "model",
-                        "parts": [{"text": "Hello, how can I help you?"}],
-                    }
-                }
-            }
-        ).encode(),  # Encode as bytes since recv(decode=False) is used
-        None,  # Add None to trigger StopAsyncIteration after first message
-    ]
-
-    with patch("{{cookiecutter.agent_directory}}.server.genai_client") as mock_genai:
-        mock_genai.aio.live.connect.return_value.__aenter__.return_value = mock_session
-        client = TestClient(app)
-        with client.websocket_connect("/ws") as websocket:
-            # Test initial connection message
-            data = websocket.receive_json()
-            assert data["status"] == "Backend is ready for conversation"
-
-            # Test sending a message
-            websocket.send_json(
-                {"setup": {"run_id": "test-run", "user_id": "test-user"}}
-            )
-
-            # Test sending audio stream
-            dummy_audio = bytes([0] * 1024)  # 1KB of silence
-            websocket.send_json(
-                {
-                    "realtimeInput": {
-                        "mediaChunks": [
-                            {
-                                "mimeType": "audio/pcm;rate=16000",
-                                "data": dummy_audio.hex(),
-                            }
-                        ]
-                    }
-                }
-            )
-
-            # Receive response as bytes
-            response = websocket.receive_bytes()
-            response_data = json.loads(response.decode())
-            assert "serverContent" in response_data
-
-            # Verify mock interactions
-            mock_genai.aio.live.connect.assert_called_once()
-            assert mock_session._ws.recv.called
-            await mock_session._ws.recv.aclose()
-
-
-@pytest.mark.asyncio
-def test_websocket_error_handling() -> None:
-    """Test websocket error handling."""
-    from {{cookiecutter.agent_directory}}.server import app
-
-    with patch("{{cookiecutter.agent_directory}}.server.genai_client") as mock_genai:
-        mock_genai.aio.live.connect.side_effect = Exception("Connection failed")
-
-        client = TestClient(app)
-        with pytest.raises(Exception) as exc:
-            with client.websocket_connect("/ws"):
-                pass
-        assert str(exc.value) == "Connection failed"