agent-starter-pack 0.3.3__py3-none-any.whl → 0.21.0__py3-none-any.whl

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

@@ -1,183 +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 app.agent import root_agent
-from app.agent_engine_app import AgentEngineApp
-{%- else %}
-
-from app.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 %}
-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 stream_query
-    message = "What's the weather in San Francisco?"
-    events = list(agent_app.stream_query(message=message, user_id="test"))
-    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,42 +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
-   # Create and activate virtual environment
-   python3 -m venv locust_env
-   source locust_env/bin/activate
-   
-   # Install required packages
-   pip install locust==2.31.1 "google-cloud-aiplatform[langchain,reasoningengine]>=1.77.0"
-   ```
-
-**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,107 +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"/v1beta1/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 = {
-            "input": {
-                "message": "What's the weather in San Francisco?",
-                "user_id": "test",
-            }
-        }
-{% 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,
-            name="/stream_messages first message",
-            stream=True,
-            params={"alt": "sse"},
-        ) as response:
-            if response.status_code == 200:
-                events = []
-                for line in response.iter_lines():
-                    if line:
-                        event = json.loads(line)
-                        events.append(event)
-                end_time = time.time()
-                total_time = end_time - start_time
-                self.environment.events.request.fire(
-                    request_type="POST",
-                    name="/stream_messages end",
-                    response_time=total_time * 1000,  # Convert to milliseconds
-                    response_length=len(json.dumps(events)),
-                    response=response,
-                    context={},
-                )
-            else:
-                response.failure(f"Unexpected status code: {response.status_code}")

src/deployment_targets/cloud_run/app/server.py

@@ -1,154 +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.
-{% if "adk" in cookiecutter.tags %}
-import os
-
-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
-
-from app.utils.tracing import CloudTraceLoggingSpanExporter
-from app.utils.typing import Feedback
-
-logging_client = google_cloud_logging.Client()
-logger = logging_client.logger(__name__)
-
-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__)))
-app: FastAPI = get_fast_api_app(agent_dir=AGENT_DIR, web=False)
-
-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 app.agent import agent
-from app.utils.tracing import CloudTraceLoggingSpanExporter
-from app.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"):
-        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")
-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)