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

agent_starter_pack/cli/main.py

@@ -21,6 +21,7 @@ from rich.console import Console
 from .commands.create import create
 from .commands.enhance import enhance
 from .commands.list import list_agents
+from .commands.register_gemini_enterprise import register_gemini_enterprise
 from .commands.setup_cicd import setup_cicd
 from .utils import display_update_message
 
@@ -57,6 +58,7 @@ def cli() -> None:
 # Register commands
 cli.add_command(create)
 cli.add_command(enhance)
+cli.add_command(register_gemini_enterprise)
 cli.add_command(setup_cicd)
 cli.add_command(list_agents, name="list")
 

agent_starter_pack/cli/utils/cicd.py

@@ -103,9 +103,10 @@ def create_github_connection(
     """
     console.print("\n🔗 Creating GitHub connection...")
 
-    # First, ensure Cloud Build API is enabled
-    console.print("🔧 Ensuring Cloud Build API is enabled...")
+    # First, ensure required APIs are enabled
+    console.print("🔧 Ensuring required APIs are enabled...")
     try:
+        # Enable Cloud Build API
         run_command(
             [
                 "gcloud",
@@ -120,13 +121,28 @@ def create_github_connection(
         )
         console.print("✅ Cloud Build API enabled")
 
-        # Wait for the API to fully initialize and create the service account
+        # Enable Secret Manager API
+        run_command(
+            [
+                "gcloud",
+                "services",
+                "enable",
+                "secretmanager.googleapis.com",
+                "--project",
+                project_id,
+            ],
+            capture_output=True,
+            check=False,  # Don't fail if already enabled
+        )
+        console.print("✅ Secret Manager API enabled")
+
+        # Wait for the APIs to fully initialize and create the service account
         console.print(
             "⏳ Waiting for Cloud Build service account to be created (this typically takes 5-10 seconds)..."
         )
         time.sleep(10)
     except subprocess.CalledProcessError as e:
-        console.print(f"⚠️ Could not enable Cloud Build API: {e}", style="yellow")
+        console.print(f"⚠️ Could not enable required APIs: {e}", style="yellow")
 
     # Get the Cloud Build service account and grant permissions with retry logic
     try:

agent_starter_pack/cli/utils/template.py

@@ -16,7 +16,10 @@ import json
 import logging
 import os
 import pathlib
+import re
 import shutil
+import subprocess
+import sys
 import tempfile
 from dataclasses import dataclass
 from typing import Any
@@ -24,7 +27,7 @@ from typing import Any
 import yaml
 from cookiecutter.main import cookiecutter
 from rich.console import Console
-from rich.prompt import IntPrompt, Prompt
+from rich.prompt import Confirm, IntPrompt, Prompt
 
 from agent_starter_pack.cli.utils.version import get_current_version
 
@@ -35,6 +38,105 @@ from .remote_template import (
 )
 
 
+def add_base_template_dependencies_interactively(
+    project_path: pathlib.Path,
+    base_dependencies: list[str],
+    base_template_name: str,
+    auto_approve: bool = False,
+) -> bool:
+    """Interactively add base template dependencies using uv add.
+
+    Args:
+        project_path: Path to the project directory
+        base_dependencies: List of dependencies from base template's extra_dependencies
+        base_template_name: Name of the base template being used
+        auto_approve: Whether to skip confirmation and auto-install
+
+    Returns:
+        True if dependencies were added successfully, False otherwise
+    """
+    if not base_dependencies:
+        return True
+
+    console = Console()
+
+    # Construct dependency string once for reuse
+    deps_str = " ".join(f"'{dep}'" for dep in base_dependencies)
+
+    # Show what dependencies will be added
+    console.print(
+        f"\n✓ Base template override: Using '{base_template_name}' as foundation",
+        style="bold cyan",
+    )
+    console.print("  This requires adding the following dependencies:", style="white")
+    for dep in base_dependencies:
+        console.print(f"    • {dep}", style="yellow")
+
+    # Ask for confirmation unless auto-approve
+    should_add = True
+    if not auto_approve:
+        should_add = Confirm.ask(
+            "\n? Add these dependencies automatically?", default=True
+        )
+
+    if not should_add:
+        console.print("\n⚠️  Skipped dependency installation.", style="yellow")
+        console.print("   To add them manually later, run:", style="dim")
+        console.print(f"       cd {project_path.name}", style="dim")
+        console.print(f"       uv add {deps_str}\n", style="dim")
+        return False
+
+    # Run uv add
+    try:
+        if auto_approve:
+            console.print(
+                f"✓ Auto-installing dependencies: {', '.join(base_dependencies)}",
+                style="bold cyan",
+            )
+        else:
+            console.print(f"\n✓ Running: uv add {deps_str}", style="bold cyan")
+
+        # Run uv add in the project directory
+        cmd = ["uv", "add"] + base_dependencies
+        result = subprocess.run(
+            cmd,
+            cwd=project_path,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        # Show success message
+        if not auto_approve:
+            # Show a summary line from uv output
+            output_lines = result.stderr.strip().split("\n")
+            for line in output_lines:
+                if "Resolved" in line or "Installed" in line:
+                    console.print(f"  {line}", style="dim")
+                    break
+
+        console.print("✓ Dependencies added successfully\n", style="bold green")
+        return True
+
+    except subprocess.CalledProcessError as e:
+        console.print(
+            f"\n✗ Failed to add dependencies: {e.stderr.strip()}", style="bold red"
+        )
+        console.print("  You can add them manually:", style="yellow")
+        console.print(f"      cd {project_path.name}", style="dim")
+        console.print(f"      uv add {deps_str}\n", style="dim")
+        return False
+    except FileNotFoundError:
+        console.print(
+            "\n✗ uv command not found. Please install uv first.", style="bold red"
+        )
+        console.print("  Install from: https://docs.astral.sh/uv/", style="dim")
+        console.print("\n  To add dependencies manually:", style="yellow")
+        console.print(f"      cd {project_path.name}", style="dim")
+        console.print(f"      uv add {deps_str}\n", style="dim")
+        return False
+
+
 def validate_agent_directory_name(agent_dir: str) -> None:
     """Validate that an agent directory name is a valid Python identifier.
 
@@ -112,9 +214,10 @@ def get_available_agents(deployment_target: str | None = None) -> dict:
     # Define priority agents that should appear first
     PRIORITY_AGENTS = [
         "adk_base",
+        "adk_a2a_base",
         "adk_live",
         "agentic_rag",
-        "langgraph_base_react",
+        "langgraph_base",
     ]
 
     agents_list = []
@@ -251,9 +354,9 @@ def prompt_session_type_selection() -> str:
             "display_name": "In-memory session",
             "description": "Session data stored in memory - ideal for stateless applications",
         },
-        "alloydb": {
-            "display_name": "AlloyDB",
-            "description": "Use AlloyDB for session management. Comes with terraform resources for deployment.",
+        "cloud_sql": {
+            "display_name": "Cloud SQL (PostgreSQL)",
+            "description": "Managed PostgreSQL database for robust session persistence",
         },
         "agent_engine": {
             "display_name": "Vertex AI Agent Engine",
@@ -458,6 +561,113 @@ def copy_data_ingestion_files(
         )
 
 
+def _extract_agent_garden_labels(
+    agent_garden: bool,
+    remote_spec: Any | None,
+    remote_template_path: pathlib.Path | None,
+) -> tuple[str | None, str | None]:
+    """Extract agent sample ID and publisher for Agent Garden labeling.
+
+    This function supports two mechanisms for extracting label information:
+    1. From remote_spec metadata (for ADK samples)
+    2. Fallback to pyproject.toml parsing (for version-locked templates)
+
+    Args:
+        agent_garden: Whether this deployment is from Agent Garden
+        remote_spec: Remote template spec with ADK samples metadata
+        remote_template_path: Path to remote template directory
+
+    Returns:
+        Tuple of (agent_sample_id, agent_sample_publisher) or (None, None) if no labels found
+    """
+    if not agent_garden:
+        return None, None
+
+    agent_sample_id = None
+    agent_sample_publisher = None
+
+    # Handle remote specs with ADK samples metadata
+    if (
+        remote_spec
+        and hasattr(remote_spec, "is_adk_samples")
+        and remote_spec.is_adk_samples
+    ):
+        # For ADK samples, template_path is like "python/agents/sample-name"
+        agent_sample_id = pathlib.Path(remote_spec.template_path).name
+        # For ADK samples, publisher is always "google"
+        agent_sample_publisher = "google"
+        logging.debug(f"Detected ADK sample from remote_spec: {agent_sample_id}")
+        return agent_sample_id, agent_sample_publisher
+
+    # Fallback: Detect ADK samples from pyproject.toml (for version-locked templates)
+    if remote_template_path:
+        pyproject_path = remote_template_path / "pyproject.toml"
+        if pyproject_path.exists():
+            try:
+                if sys.version_info >= (3, 11):
+                    import tomllib
+                else:
+                    import tomli as tomllib
+
+                with open(pyproject_path, "rb") as toml_file:
+                    pyproject_data = tomllib.load(toml_file)
+
+                # Extract project name from pyproject.toml
+                project_name_from_toml = pyproject_data.get("project", {}).get("name")
+
+                if project_name_from_toml:
+                    agent_sample_id = project_name_from_toml
+                    agent_sample_publisher = "google"  # ADK samples are from Google
+                    logging.debug(
+                        f"Detected ADK sample from pyproject.toml: {agent_sample_id}"
+                    )
+            except Exception as e:
+                logging.debug(f"Failed to read pyproject.toml: {e}")
+
+    return agent_sample_id, agent_sample_publisher
+
+
+def _inject_app_object_if_missing(
+    agent_py_path: pathlib.Path, agent_directory: str, console: Console
+) -> None:
+    """Inject app object into agent.py if missing (backward compatibility for ADK).
+
+    Args:
+        agent_py_path: Path to the agent.py file
+        agent_directory: Name of the agent directory for logging
+        console: Rich console for user feedback
+    """
+    try:
+        content = agent_py_path.read_text(encoding="utf-8")
+        # Check for app object (assignment, function definition, or import)
+        app_patterns = [
+            r"^\s*app\s*=",  # assignment: app = ...
+            r"^\s*def\s+app\(",  # function: def app(...)
+            r"from\s+.*\s+import\s+.*\bapp\b",  # import: from ... import app
+        ]
+        has_app = any(
+            re.search(pattern, content, re.MULTILINE) for pattern in app_patterns
+        )
+
+        if not has_app:
+            console.print(
+                f"ℹ️  Adding 'app' object to [cyan]{agent_directory}/agent.py[/cyan] for backward compatibility",
+                style="dim",
+            )
+            # Add import and app object at the end of the file
+            content = content.rstrip()
+            if "from google.adk.apps.app import App" not in content:
+                content += "\n\nfrom google.adk.apps.app import App\n"
+            content += '\napp = App(root_agent=root_agent, name="app")\n'
+
+            # Write the modified content back
+            agent_py_path.write_text(content, encoding="utf-8")
+    except Exception as e:
+        logging.warning(
+            f"Could not inject app object into {agent_directory}/agent.py: {type(e).__name__}: {e}"
+        )
+
+
 def process_template(
     agent_name: str,
     template_dir: pathlib.Path,
@@ -498,6 +708,9 @@ def process_template(
     logging.debug(f"Include pipeline: {datastore}")
     logging.debug(f"Output directory: {output_dir}")
 
+    # Create console for user feedback
+    console = Console()
+
     def get_agent_directory(
         template_config: dict[str, Any], cli_overrides: dict[str, Any] | None = None
     ) -> str:
@@ -559,13 +772,9 @@ def process_template(
             os.chdir(temp_path)  # Change to temp directory
 
             # Extract agent sample info for labeling when using agent garden with remote templates
-            agent_sample_id = None
-            agent_sample_publisher = None
-            if agent_garden and remote_spec and remote_spec.is_adk_samples:
-                # For ADK samples, template_path is like "python/agents/sample-name"
-                agent_sample_id = pathlib.Path(remote_spec.template_path).name
-                # For ADK samples, publisher is always "google"
-                agent_sample_publisher = "google"
+            agent_sample_id, agent_sample_publisher = _extract_agent_garden_labels(
+                agent_garden, remote_spec, remote_template_path
+            )
 
             # Create the cookiecutter template structure
             cookiecutter_template = temp_path / "template"
@@ -717,14 +926,14 @@ def process_template(
                 / "docs"
                 / "adk-cheatsheet.md"
             )
-            with open(adk_cheatsheet_path, encoding="utf-8") as f:
-                adk_cheatsheet_content = f.read()
+            with open(adk_cheatsheet_path, encoding="utf-8") as md_file:
+                adk_cheatsheet_content = md_file.read()
 
             llm_txt_path = (
                 pathlib.Path(__file__).parent.parent.parent.parent / "llm.txt"
             )
-            with open(llm_txt_path, encoding="utf-8") as f:
-                llm_txt_content = f.read()
+            with open(llm_txt_path, encoding="utf-8") as txt_file:
+                llm_txt_content = txt_file.read()
 
             cookiecutter_config = {
                 "project_name": project_name,
@@ -738,6 +947,7 @@ def process_template(
                 "tags": tags,
                 "is_adk": "adk" in tags,
                 "is_adk_live": "adk_live" in tags,
+                "is_a2a": "a2a" in tags,
                 "deployment_target": deployment_target or "",
                 "cicd_runner": cicd_runner or "google_cloud_build",
                 "session_type": session_type or "",
@@ -777,8 +987,8 @@ def process_template(
 
             with open(
                 cookiecutter_template / "cookiecutter.json", "w", encoding="utf-8"
-            ) as f:
-                json.dump(cookiecutter_config, f, indent=4)
+            ) as json_file:
+                json.dump(cookiecutter_config, json_file, indent=4)
 
             logging.debug(f"Template structure created at {cookiecutter_template}")
             logging.debug(
@@ -859,6 +1069,19 @@ def process_template(
                 )
                 logging.debug("Remote template files copied successfully")
 
+                # Inject app object if missing (backward compatibility for ADK remote templates)
+                # Only inject for ADK agents with agent_engine deployment
+                is_adk = "adk" in tags
+                agent_py_path = generated_project_dir / agent_directory / "agent.py"
+                if (
+                    is_adk
+                    and agent_py_path.exists()
+                    and deployment_target == "agent_engine"
+                ):
+                    _inject_app_object_if_missing(
+                        agent_py_path, agent_directory, console
+                    )
+
             # Move the generated project to the final destination
             generated_project_dir = temp_path / project_name
 
@@ -927,8 +1150,12 @@ def process_template(
                                             file_template_dir / "cookiecutter.json",
                                             "w",
                                             encoding="utf-8",
-                                        ) as f:
-                                            json.dump(cookiecutter_config, f, indent=4)
+                                        ) as config_file:
+                                            json.dump(
+                                                cookiecutter_config,
+                                                config_file,
+                                                indent=4,
+                                            )
 
                                         # Process the file template
                                         cookiecutter(
@@ -1089,13 +1316,13 @@ def process_template(
 
                 # Replace cookiecutter project name with actual project name in lock file
                 lock_file_path = final_destination / "uv.lock"
-                with open(lock_file_path, "r+", encoding="utf-8") as f:
-                    content = f.read()
-                    f.seek(0)
-                    f.write(
+                with open(lock_file_path, "r+", encoding="utf-8") as lock_file:
+                    content = lock_file.read()
+                    lock_file.seek(0)
+                    lock_file.write(
                         content.replace("{{cookiecutter.project_name}}", project_name)
                     )
-                    f.truncate()
+                    lock_file.truncate()
                 logging.debug(f"Updated project name in lock file at {lock_file_path}")
 
         except Exception as e:
@@ -1185,6 +1412,11 @@ def copy_frontend_files(frontend_type: str, project_template: pathlib.Path) -> N
         logging.debug("Frontend type is 'None' or empty, skipping frontend files")
         return
 
+    # Skip copying if frontend_type is "inspector" - it's installed at runtime via make inspector
+    if frontend_type == "inspector":
+        logging.debug("Frontend type is 'inspector', skipping (installed at runtime)")
+        return
+
     # Get the frontends directory path
     frontends_path = (
         pathlib.Path(__file__).parent.parent.parent / "frontends" / frontend_type

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

@@ -47,7 +47,7 @@ def start_server() -> subprocess.Popen[str]:
         sys.executable,
         "-m",
         "uvicorn",
-        "app.utils.expose_app:app",
+        "app.app_utils.expose_app:app",
         "--host",
         "0.0.0.0",
         "--port",
@@ -202,8 +202,8 @@ def test_feedback_endpoint(server_fixture: subprocess.Popen[str]) -> None:
     feedback_data = {
         "score": 5,
         "text": "Great response!",
-        "run_id": "test-run-123",
-        "user_id": "test-user",
+        "user_id": "test-user-123",
+        "session_id": "test-session-123",
         "log_type": "feedback",
     }
 
@@ -213,32 +213,124 @@ def test_feedback_endpoint(server_fixture: subprocess.Popen[str]) -> None:
     logger.info("Feedback endpoint test passed")
 {% else %}
 
+# mypy: disable-error-code="arg-type"
+{%- if cookiecutter.is_a2a %}
+
+import os
+
+import pytest
+
+from {{cookiecutter.agent_directory}}.agent_engine_app import AgentEngineApp
+from tests.helpers import (
+    build_get_request,
+    build_post_request,
+    poll_task_completion,
+)
+{%- elif cookiecutter.is_adk %}
+
 import logging
 
 import pytest
-{%- if cookiecutter.is_adk %}
 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 %}
 
+import logging
+
+import pytest
+
 from {{cookiecutter.agent_directory}}.agent_engine_app import AgentEngineApp
 {%- endif %}
+{%- if cookiecutter.is_a2a %}
 
 
 @pytest.fixture
 def agent_app() -> AgentEngineApp:
     """Fixture to create and set up AgentEngineApp instance"""
-{%- if cookiecutter.is_adk %}
-    app = AgentEngineApp(agent=root_agent)
+    from {{cookiecutter.agent_directory}}.agent_engine_app import agent_engine
+
+    agent_engine.set_up()
+    return agent_engine
 {%- else %}
-    app = AgentEngineApp()
-{%- endif %}
-    app.set_up()
-    return app
 
-{% if cookiecutter.is_adk %}
+
+@pytest.fixture
+def agent_app() -> AgentEngineApp:
+    """Fixture to create and set up AgentEngineApp instance"""
+    from {{cookiecutter.agent_directory}}.agent_engine_app import agent_engine
+
+    agent_engine.set_up()
+    return agent_engine
+{% endif %}
+{%- if cookiecutter.is_a2a %}
+
+
+@pytest.mark.asyncio
+async def test_agent_on_message_send(agent_app: AgentEngineApp) -> None:
+    """Test complete A2A message workflow from send to task completion with artifacts."""
+    # Send message
+    message_data = {
+        "message": {
+            "messageId": f"msg-{os.urandom(8).hex()}",
+            "content": [{"text": "What is the capital of France?"}],
+            "role": "ROLE_USER",
+        },
+    }
+    response = await agent_app.on_message_send(
+        request=build_post_request(message_data),
+        context=None,
+    )
+
+    # Verify task creation
+    assert "task" in response and "id" in response["task"], (
+        "Expected task with ID in response"
+    )
+
+    # Poll for completion
+    final_response = await poll_task_completion(agent_app, response["task"]["id"])
+
+    # Verify artifacts
+    assert final_response.get("artifacts"), "Expected artifacts in completed task"
+    artifact = final_response["artifacts"][0]
+    assert artifact.get("parts") and artifact["parts"][0].get("text"), (
+        "Expected artifact with text content"
+    )
+
+
+@pytest.mark.asyncio
+async def test_agent_card(agent_app: AgentEngineApp) -> None:
+    """Test agent card retrieval and validation of required A2A fields."""
+    response = await agent_app.handle_authenticated_agent_card(
+        request=build_get_request(None),
+        context=None,
+    )
+
+    # Verify core agent card fields
+    assert response.get("name") == "root_agent", "Expected agent name 'root_agent'"
+    assert response.get("protocolVersion") == "0.3.0", "Expected protocol version 0.3.0"
+    assert response.get("preferredTransport") == "HTTP+JSON", (
+        "Expected HTTP+JSON transport"
+    )
+
+    # Verify capabilities
+    capabilities = response.get("capabilities", {})
+    assert capabilities.get("streaming") is False, "Expected streaming disabled"
+
+    # Verify skills
+    skills = response.get("skills", [])
+    assert len(skills) > 0, "Expected at least one skill"
+    for skill in skills:
+        assert all(key in skill for key in ["id", "name", "description"]), (
+            "Expected id, name, and description in each skill"
+        )
+
+    # Verify extended card support
+    assert response.get("supportsAuthenticatedExtendedCard") is True, (
+        "Expected supportsAuthenticatedExtendedCard to be True"
+    )
+{% elif cookiecutter.is_adk %}
+
 @pytest.mark.asyncio
 async def test_agent_stream_query(agent_app: AgentEngineApp) -> None:
     """
@@ -276,7 +368,8 @@ def test_agent_feedback(agent_app: AgentEngineApp) -> None:
     feedback_data = {
         "score": 5,
         "text": "Great response!",
-        "invocation_id": "test-run-123",
+        "user_id": "test-user-456",
+        "session_id": "test-session-456",
     }
 
     # Should not raise any exceptions
@@ -287,12 +380,14 @@ def test_agent_feedback(agent_app: AgentEngineApp) -> None:
         invalid_feedback = {
             "score": "invalid",  # Score must be numeric
             "text": "Bad feedback",
-            "invocation_id": "test-run-123",
+            "user_id": "test-user-789",
+            "session_id": "test-session-789",
         }
         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.
@@ -368,7 +463,8 @@ def test_agent_feedback(agent_app: AgentEngineApp) -> None:
     feedback_data = {
         "score": 5,
         "text": "Great response!",
-        "run_id": "test-run-123",
+        "user_id": "test-user-456",
+        "session_id": "test-session-456",
     }
 
     # Should not raise any exceptions
@@ -379,7 +475,8 @@ def test_agent_feedback(agent_app: AgentEngineApp) -> None:
         invalid_feedback = {
             "score": "invalid",  # Score must be numeric
             "text": "Bad feedback",
-            "run_id": "test-run-123",
+            "user_id": "test-user-789",
+            "session_id": "test-session-789",
         }
         agent_app.register_feedback(invalid_feedback)
 

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

@@ -16,13 +16,13 @@ The load test simulates realistic user interactions by:
 Launch the expose app server in a separate terminal, pointing to your deployed agent engine:
 
 ```bash
-uv run python -m app.utils.expose_app --mode remote --remote-id <your-agent-engine-id>
+uv run python -m app.app_utils.expose_app --mode remote --remote-id <your-agent-engine-id>
 ```
 
 Or if you have `deployment_metadata.json` in your project root:
 
 ```bash
-uv run python -m app.utils.expose_app --mode remote
+uv run python -m app.app_utils.expose_app --mode remote
 ```
 
 **2. Execute the Load Test:**