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

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"

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

@@ -1,186 +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 logging
-
-import pytest
-{%- if "adk" in cookiecutter.tags %}
-from google.adk.events.event import Event
-
-from {{cookiecutter.agent_directory}}.agent import root_agent
-from {{cookiecutter.agent_directory}}.agent_engine_app import AgentEngineApp
-{%- else %}
-
-from {{cookiecutter.agent_directory}}.agent_engine_app import AgentEngineApp
-{%- endif %}
-
-
-@pytest.fixture
-def agent_app() -> AgentEngineApp:
-    """Fixture to create and set up AgentEngineApp instance"""
-{%- if "adk" in cookiecutter.tags %}
-    app = AgentEngineApp(agent=root_agent)
-{%- else %}
-    app = AgentEngineApp()
-{%- endif %}
-    app.set_up()
-    return app
-
-{% if "adk" in cookiecutter.tags %}
-@pytest.mark.asyncio
-async def test_agent_stream_query(agent_app: AgentEngineApp) -> None:
-    """
-    Integration test for the agent stream query functionality.
-    Tests that the agent returns valid streaming responses.
-    """
-    # Create message and events for the async_stream_query
-    message = "What's the weather in San Francisco?"
-    events = []
-    async for event in agent_app.async_stream_query(message=message, user_id="test"):
-        events.append(event)
-    assert len(events) > 0, "Expected at least one chunk in response"
-
-    # Check for valid content in the response
-    has_text_content = False
-    for event in events:
-        validated_event = Event.model_validate(event)
-        content = validated_event.content
-        if (
-            content is not None
-            and content.parts
-            and any(part.text for part in content.parts)
-        ):
-            has_text_content = True
-            break
-
-    assert has_text_content, "Expected at least one event with text content"
-
-
-def test_agent_feedback(agent_app: AgentEngineApp) -> None:
-    """
-    Integration test for the agent feedback functionality.
-    Tests that feedback can be registered successfully.
-    """
-    feedback_data = {
-        "score": 5,
-        "text": "Great response!",
-        "invocation_id": "test-run-123",
-    }
-
-    # Should not raise any exceptions
-    agent_app.register_feedback(feedback_data)
-
-    # Test invalid feedback
-    with pytest.raises(ValueError):
-        invalid_feedback = {
-            "score": "invalid",  # Score must be numeric
-            "text": "Bad feedback",
-            "invocation_id": "test-run-123",
-        }
-        agent_app.register_feedback(invalid_feedback)
-
-    logging.info("All assertions passed for agent feedback test")
-{% else %}
-def test_agent_stream_query(agent_app: AgentEngineApp) -> None:
-    """
-    Integration test for the agent stream query functionality.
-    Tests that the agent returns valid streaming responses.
-    """
-    input_dict = {
-        "messages": [
-            {"type": "human", "content": "Test message"},
-        ],
-        "user_id": "test-user",
-        "session_id": "test-session",
-    }
-
-    events = list(agent_app.stream_query(input=input_dict))
-
-    assert len(events) > 0, "Expected at least one chunk in response"
-
-    # Verify each event is a tuple of message and metadata
-    for event in events:
-        assert isinstance(event, list), "Event should be a list"
-        assert len(event) == 2, "Event should contain message and metadata"
-        message, _ = event
-
-        # Verify message structure
-        assert isinstance(message, dict), "Message should be a dictionary"
-        assert message["type"] == "constructor"
-        assert "kwargs" in message, "Constructor message should have kwargs"
-
-    # Verify at least one message has content
-    has_content = False
-    for event in events:
-        message = event[0]
-        if message.get("type") == "constructor" and "content" in message["kwargs"]:
-            has_content = True
-            break
-    assert has_content, "At least one message should have content"
-
-
-def test_agent_query(agent_app: AgentEngineApp) -> None:
-    """
-    Integration test for the agent query functionality.
-    Tests that the agent returns valid responses.
-    """
-    input_dict = {
-        "messages": [
-            {"type": "human", "content": "Test message"},
-        ],
-        "user_id": "test-user",
-        "session_id": "test-session",
-    }
-
-    response = agent_app.query(input=input_dict)
-
-    # Basic response validation
-    assert isinstance(response, dict), "Response should be a dictionary"
-    assert "messages" in response, "Response should contain messages"
-    assert len(response["messages"]) > 0, "Response should have at least one message"
-
-    # Validate last message is AI response with content
-    message = response["messages"][-1]
-    kwargs = message["kwargs"]
-    assert kwargs["type"] == "ai", "Last message should be AI response"
-    assert len(kwargs["content"]) > 0, "AI message content should not be empty"
-
-    logging.info("All assertions passed for agent query test")
-
-
-def test_agent_feedback(agent_app: AgentEngineApp) -> None:
-    """
-    Integration test for the agent feedback functionality.
-    Tests that feedback can be registered successfully.
-    """
-    feedback_data = {
-        "score": 5,
-        "text": "Great response!",
-        "run_id": "test-run-123",
-    }
-
-    # Should not raise any exceptions
-    agent_app.register_feedback(feedback_data)
-
-    # Test invalid feedback
-    with pytest.raises(ValueError):
-        invalid_feedback = {
-            "score": "invalid",  # Score must be numeric
-            "text": "Bad feedback",
-            "run_id": "test-run-123",
-        }
-        agent_app.register_feedback(invalid_feedback)
-
-    logging.info("All assertions passed for agent feedback test")
-{% endif %}

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

@@ -1,37 +0,0 @@
-# Robust Load Testing for Generative AI Applications
-
-This directory provides a comprehensive load testing framework for your Generative AI application, leveraging the power of [Locust](http://locust.io), a leading open-source load testing tool.
-
-##  Load Testing
-
-Before running load tests, ensure you have deployed the backend remotely.
-
-Follow these steps to execute load tests:
-
-**1. Deploy the Backend Remotely:**
-   ```bash
-   gcloud config set project <your-dev-project-id>
-   make backend
-   ```
-
-**2. Create a Virtual Environment for Locust:**
-   It's recommended to use a separate terminal tab and create a virtual environment for Locust to avoid conflicts with your application's Python environment.
-
-   ```bash
-   python3 -m venv .locust_env && source .locust_env/bin/activate && pip install locust==2.31.1
-   ```
-
-**3. Execute the Load Test:**
-   Trigger the Locust load test with the following command:
-
-   ```bash
-   export _AUTH_TOKEN=$(gcloud auth print-access-token -q)
-   locust -f tests/load_test/load_test.py \
-   --headless \
-   -t 30s -u 5 -r 2 \
-   --csv=tests/load_test/.results/results \
-   --html=tests/load_test/.results/report.html
-   ```
-
-   This command initiates a 30-second load test, simulating 2 users spawning per second, reaching a maximum of 10 concurrent users.
-

src/deployment_targets/agent_engine/tests/load_test/load_test.py

@@ -1,126 +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
-import time
-
-from locust import HttpUser, between, task
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger(__name__)
-
-# Initialize Vertex AI and load agent config
-with open("deployment_metadata.json") as f:
-    remote_agent_engine_id = json.load(f)["remote_agent_engine_id"]
-
-parts = remote_agent_engine_id.split("/")
-project_id = parts[1]
-location = parts[3]
-engine_id = parts[5]
-
-# Convert remote agent engine ID to streaming URL.
-base_url = f"https://{location}-aiplatform.googleapis.com"
-url_path = f"/v1/projects/{project_id}/locations/{location}/reasoningEngines/{engine_id}:streamQuery"
-
-logger.info("Using remote agent engine ID: %s", remote_agent_engine_id)
-logger.info("Using base URL: %s", base_url)
-logger.info("Using URL path: %s", url_path)
-
-
-class ChatStreamUser(HttpUser):
-    """Simulates a user interacting with the chat stream API."""
-
-    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
-    host = base_url  # Set the base host URL for Locust
-
-    @task
-    def chat_stream(self) -> None:
-        """Simulates a chat stream interaction."""
-        headers = {"Content-Type": "application/json"}
-        headers["Authorization"] = f"Bearer {os.environ['_AUTH_TOKEN']}"
-{% if "adk" in cookiecutter.tags %}
-        data = {
-            "class_method": "async_stream_query",
-            "input": {
-                "user_id": "test",
-                "message": "What's the weather in San Francisco?",
-            },
-        }
-{% else %}
-        data = {
-            "input": {
-                "input": {
-                    "messages": [
-                        {"type": "human", "content": "Hello, AI!"},
-                        {"type": "ai", "content": "Hello!"},
-                        {"type": "human", "content": "How are you?"},
-                    ]
-                },
-                "config": {
-                    "metadata": {"user_id": "test-user", "session_id": "test-session"}
-                },
-            }
-        }
-{% endif %}
-        start_time = time.time()
-        with self.client.post(
-            url_path,
-            headers=headers,
-            json=data,
-            catch_response=True,
-{%- if "adk" in cookiecutter.tags %}
-            name="/streamQuery async_stream_query",
-{%- else %}
-            name="/stream_messages first message",
-{%- endif %}
-            stream=True,
-            params={"alt": "sse"},
-        ) as response:
-            if response.status_code == 200:
-                events = []
-                for line in response.iter_lines():
-                    if line:
-                        line_str = line.decode("utf-8")
-                        events.append(line_str)
-
-                        if "429 Too Many Requests" in line_str:
-                            self.environment.events.request.fire(
-                                request_type="POST",
-                                name=f"{url_path} rate_limited 429s",
-                                response_time=0,
-                                response_length=len(line),
-                                response=response,
-                                context={},
-                            )
-                end_time = time.time()
-                total_time = end_time - start_time
-                self.environment.events.request.fire(
-                    request_type="POST",
-{%- if "adk" in cookiecutter.tags %}
-                    name="/streamQuery end",
-{%- else %}
-                    name="/stream_messages end",
-{%- endif %}
-                    response_time=total_time * 1000,  # Convert to milliseconds
-                    response_length=len(events),
-                    response=response,
-                    context={},
-                )
-            else:
-                response.failure(f"Unexpected status code: {response.status_code}")

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

@@ -1,122 +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 time
-{%- if "adk" in cookiecutter.tags %}
-import uuid
-
-import requests
-from locust import HttpUser, between, task
-{%- else %}
-
-from locust import HttpUser, between, task
-{%- endif %}
-{% if "adk" in cookiecutter.tags %}
-ENDPOINT = "/run_sse"
-{% else %}
-ENDPOINT = "/stream_messages"
-{% endif %}
-
-class ChatStreamUser(HttpUser):
-    """Simulates a user interacting with the chat stream API."""
-
-    wait_time = between(1, 3)  # Wait 1-3 seconds between tasks
-
-    @task
-    def chat_stream(self) -> None:
-        """Simulates a chat stream interaction."""
-        headers = {"Content-Type": "application/json"}
-        if os.environ.get("_ID_TOKEN"):
-            headers["Authorization"] = f"Bearer {os.environ['_ID_TOKEN']}"
-{%- if "adk" in cookiecutter.tags %}
-        # Create session first
-        user_id = f"user_{uuid.uuid4()}"
-        session_data = {"state": {"preferred_language": "English", "visit_count": 1}}
-
-        session_url = f"{self.client.base_url}/apps/{{cookiecutter.agent_directory}}/users/{user_id}/sessions"
-        session_response = requests.post(
-            session_url,
-            headers=headers,
-            json=session_data,
-            timeout=10,
-        )
-
-        # Get session_id from response
-        session_id = session_response.json()["id"]
-
-        # Send chat message
-        data = {
-            "app_name": "{{cookiecutter.agent_directory}}",
-            "user_id": user_id,
-            "session_id": session_id,
-            "new_message": {
-                "role": "user",
-                "parts": [{"text": "Hello! Weather in New york?"}],
-            },
-            "streaming": True,
-        }
-{%- else %}
-        data = {
-            "input": {
-                "messages": [
-                    {"type": "human", "content": "Hello, AI!"},
-                    {"type": "ai", "content": "Hello!"},
-                    {"type": "human", "content": "Who are you?"},
-                ]
-            },
-            "config": {
-                "metadata": {"user_id": "test-user", "session_id": "test-session"}
-            },
-        }
-{%- endif %}
-        start_time = time.time()
-
-        with self.client.post(
-            ENDPOINT,
-            name=f"{ENDPOINT} message",
-            headers=headers,
-            json=data,
-            catch_response=True,
-            stream=True,
-            params={"alt": "sse"},
-        ) as response:
-            if response.status_code == 200:
-                events = []
-                for line in response.iter_lines():
-                    if line:
-                        line_str = line.decode("utf-8")
-                        events.append(line_str)
-
-                        if "429 Too Many Requests" in line_str:
-                            self.environment.events.request.fire(
-                                request_type="POST",
-                                name=f"{ENDPOINT} rate_limited 429s",
-                                response_time=0,
-                                response_length=len(line),
-                                response=response,
-                                context={},
-                            )
-                end_time = time.time()
-                total_time = end_time - start_time
-                self.environment.events.request.fire(
-                    request_type="POST",
-                    name=f"{ENDPOINT} end",
-                    response_time=total_time * 1000,  # Convert to milliseconds
-                    response_length=len(events),
-                    response=response,
-                    context={},
-                )
-            else:
-                response.failure(f"Unexpected status code: {response.status_code}")

src/resources/idx/.idx/dev.nix

@@ -1,50 +0,0 @@
-
-# To learn more about how to use Nix to configure your environment
-# see: https://firebase.google.com/docs/studio/customize-workspace
-{ pkgs, ... }: {
-  # Which nixpkgs channel to use.
-  channel = "stable-24.11"; # or "unstable"
-
-  # Use https://search.nixos.org/packages to find packages
-  packages = [
-    pkgs.uv
-    pkgs.gnumake
-    pkgs.terraform
-    pkgs.gh
-  ];
-  # Sets environment variables in the workspace
-  env = {};
-  idx = {
-    # Search for the extensions you want on https://open-vsx.org/ and use "publisher.id"
-    extensions = [
-      "ms-toolsai.jupyter"
-      "ms-python.python"
-      "krish-r.vscode-toggle-terminal"
-    ];
-    workspace = {
-      # Runs when a workspace is first created with this `dev.nix` file
-      onCreate = {
-        create-venv = ''
-        # Load environment variables from .env file if it exists
-        source .env
-        echo "Logging into gcloud..."
-        echo "Please authenticate with Google Cloud by following the prompts."
-        gcloud auth login --update-adc --brief --quiet
-
-        echo "Setting gcloud project..."
-        gcloud config set project $GOOGLE_CLOUD_PROJECT
-
-        echo "Running agent starter pack creation..."
-        uvx agent-starter-pack create $AGENT_NAME
-        code ~/$WS_NAME/$AGENT_NAME/README.md
-        exec bash
-        '';
-        # Open editors for the following files by default, if they exist:
-        default.openFiles = [];
-      };
-      # To run something each time the workspace is (re)started, use the `onStart` hook
-    };
-    # Enable previews and customize configuration
-    previews = {};
-  };
-}

src/resources/idx/idx-template.json

@@ -1,21 +0,0 @@
-{
-  "name": "Agent Starter Pack",
-  "description": "Production-ready Gen AI Agent templates for Google Cloud. Addressing common challenges (Deployment & Operations, Evaluation, Customization, Observability) in building and deploying GenAI agents.",
-  "icon": "https://github.com/GoogleCloudPlatform/agent-starter-pack/blob/main/docs/images/icon.png?raw=true",
-  "params": [
-    {
-      "id": "agent_name",
-      "name": "Agent Name",
-      "description": "The name of the agent being created.",
-      "type": "string",
-      "required": true
-    },
-    {
-      "id": "google_cloud_project_id",
-      "name": "Your Google Cloud Project ID",
-      "description": "The Google Cloud Platform Project ID where resources will be managed.",
-      "type": "string",
-      "required": true
-    }
-  ]
-}