agent-starter-pack 0.13.1__py3-none-any.whl → 0.14.1__py3-none-any.whl

agents/agentic_rag/notebooks/evaluating_adk_agent.ipynb

@@ -234,6 +234,7 @@
       "outputs": [],
       "source": [
         "import json\n",
+        "import asyncio\n",
         "\n",
         "# General\n",
         "import random\n",
@@ -285,7 +286,7 @@
         "    return \"\".join(random.choices(string.ascii_lowercase + string.digits, k=length))\n",
         "\n",
         "\n",
-        "def parse_adk_output_to_dictionary(events: list[Event]) -> dict[str, Any]:\n",
+        "def parse_adk_output_to_dictionary(events: list[Event], *, as_json: bool = False):\n",
         "    \"\"\"\n",
         "    Parse ADK event output into a structured dictionary format,\n",
         "    with the predicted trajectory dumped as a JSON string.\n",
@@ -293,63 +294,54 @@
         "    \"\"\"\n",
         "\n",
         "    final_response = \"\"\n",
-        "    predicted_trajectory_list = []\n",
+        "    trajectory = []\n",
         "\n",
         "    for event in events:\n",
-        "        # Ensure content and parts exist before accessing them\n",
-        "        if not event.content or not event.content.parts:\n",
+        "        if not getattr(event, \"content\", None) or not getattr(event.content, \"parts\", None):\n",
         "            continue\n",
-        "\n",
-        "        # Iterate through ALL parts in the event's content\n",
         "        for part in event.content.parts:\n",
-        "            if part.function_call:\n",
-        "                tool_info = {\n",
+        "            if getattr(part, \"function_call\", None):\n",
+        "                info = {\n",
         "                    \"tool_name\": part.function_call.name,\n",
         "                    \"tool_input\": dict(part.function_call.args),\n",
         "                }\n",
-        "                # Ensure we don't add duplicates if the same call appears somehow\n",
-        "                if tool_info not in predicted_trajectory_list:\n",
-        "                    predicted_trajectory_list.append(tool_info)\n",
-        "\n",
-        "            # The final text response is usually in the last event from the model\n",
-        "            if event.content.role == \"model\" and part.text:\n",
-        "                # Overwrite response; the last text response found is likely the final one\n",
+        "                if info not in trajectory:\n",
+        "                    trajectory.append(info)\n",
+        "            if event.content.role == \"model\" and getattr(part, \"text\", None):\n",
         "                final_response = part.text.strip()\n",
         "\n",
-        "    # Dump the collected trajectory list into a JSON string\n",
-        "    final_output = {\n",
-        "        \"response\": str(final_response),\n",
-        "        \"predicted_trajectory\": json.dumps(predicted_trajectory_list),\n",
-        "    }\n",
+        "    if as_json:\n",
+        "        trajectory_out = json.dumps(trajectory)\n",
+        "    else:\n",
+        "        trajectory_out = trajectory\n",
         "\n",
-        "    return final_output\n",
+        "    return {\"response\": final_response, \"predicted_trajectory\": trajectory_out}\n",
         "\n",
         "\n",
         "def format_output_as_markdown(output: dict) -> str:\n",
         "    \"\"\"Convert the output dictionary to a formatted markdown string.\"\"\"\n",
-        "    markdown = \"### AI Response\\n\"\n",
-        "    markdown += f\"{output['response']}\\n\\n\"\n",
-        "\n",
+        "    markdown = \"### AI Response\\n\" + output[\"response\"] + \"\\n\\n\"\n",
         "    if output[\"predicted_trajectory\"]:\n",
-        "        output[\"predicted_trajectory\"] = json.loads(output[\"predicted_trajectory\"])\n",
         "        markdown += \"### Function Calls\\n\"\n",
         "        for call in output[\"predicted_trajectory\"]:\n",
         "            markdown += f\"- **Function**: `{call['tool_name']}`\\n\"\n",
-        "            markdown += \"  - **Arguments**:\\n\"\n",
+        "            markdown += \"  - **Arguments**\\n\"\n",
         "            for key, value in call[\"tool_input\"].items():\n",
         "                markdown += f\"    - `{key}`: `{value}`\\n\"\n",
-        "\n",
         "    return markdown\n",
         "\n",
         "\n",
         "def display_eval_report(eval_result: pd.DataFrame) -> None:\n",
         "    \"\"\"Display the evaluation results.\"\"\"\n",
-        "    metrics_df = pd.DataFrame.from_dict(eval_result.summary_metrics, orient=\"index\").T\n",
         "    display(Markdown(\"### Summary Metrics\"))\n",
-        "    display(metrics_df)\n",
-        "\n",
-        "    display(Markdown(\"### Row-wise Metrics\"))\n",
-        "    display(eval_result.metrics_table)\n",
+        "    display(\n",
+        "        pd.DataFrame(\n",
+        "            eval_result.summary_metrics.items(), columns=[\"metric\", \"value\"]\n",
+        "        )\n",
+        "    )\n",
+        "    if getattr(eval_result, \"metrics_table\", None) is not None:\n",
+        "        display(Markdown(\"### Row‑wise Metrics\"))\n",
+        "        display(eval_result.metrics_table.head())\n",
         "\n",
         "\n",
         "def display_drilldown(row: pd.Series) -> None:\n",
@@ -586,37 +578,49 @@
       },
       "outputs": [],
       "source": [
-        "def agent_parsed_outcome(query):\n",
-        "\n",
-        "    app_name = \"product_research_app\"\n",
-        "    user_id = \"user_one\"\n",
-        "    session_id = \"session_one\"\n",
-        "\n",
-        "    product_research_agent = Agent(\n",
-        "        name=\"ProductResearchAgent\",\n",
-        "        model=model,\n",
-        "        description=\"An agent that performs product research.\",\n",
-        "        instruction=f\"\"\"\n",
-        "        Analyze this user request: '{query}'.\n",
-        "        If the request is about price, use get_product_price tool.\n",
-        "        Otherwise, use get_product_details tool to get product information.\n",
-        "        \"\"\",\n",
-        "        tools=[get_product_details, get_product_price],\n",
-        "    )\n",
-        "\n",
-        "    session_service = InMemorySessionService()\n",
-        "    _ = session_service.create_session(\n",
-        "        app_name=app_name, user_id=user_id, session_id=session_id\n",
-        "    )\n",
-        "    runner = Runner(\n",
-        "        agent=product_research_agent, app_name=app_name, session_service=session_service\n",
-        "    )\n",
-        "\n",
-        "    content = types.Content(role=\"user\", parts=[types.Part(text=query)])\n",
-        "    events = list(\n",
-        "        runner.run(user_id=user_id, session_id=session_id, new_message=content)\n",
-        "    )\n",
-        "    return parse_adk_output_to_dictionary(events)"
+        "async def agent_parsed_outcome(query):\n",
+        "   app_name = \"product_research_app\"\n",
+        "   user_id = \"user_one\"\n",
+        "   session_id = \"session_one\"\n",
+        "   \n",
+        "   product_research_agent = Agent(\n",
+        "       name=\"ProductResearchAgent\",\n",
+        "       model=model,\n",
+        "       description=\"An agent that performs product research.\",\n",
+        "       instruction=f\"\"\"\n",
+        "       Analyze this user request: '{query}'.\n",
+        "       If the request is about price, use get_product_price tool.\n",
+        "       Otherwise, use get_product_details tool to get product information.\n",
+        "       \"\"\",\n",
+        "       tools=[get_product_details, get_product_price],\n",
+        "   )\n",
+        "\n",
+        "   session_service = InMemorySessionService()\n",
+        "   await session_service.create_session(\n",
+        "       app_name=app_name, user_id=user_id, session_id=session_id\n",
+        "   )\n",
+        "\n",
+        "   runner = Runner(\n",
+        "       agent=product_research_agent, app_name=app_name, session_service=session_service\n",
+        "   )\n",
+        "\n",
+        "   content = types.Content(role=\"user\", parts=[types.Part(text=query)])\n",
+        "   events = [event async for event in runner.run_async(user_id=user_id, session_id=session_id, new_message=content)]\n",
+        "   \n",
+        "   return parse_adk_output_to_dictionary(events)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# --- Sync wrapper for Vertex‑AI evaluation\n",
+        "def agent_parsed_outcome_sync(prompt: str):\n",
+        "    result = asyncio.run(agent_parsed_outcome(prompt))\n",
+        "    result[\"predicted_trajectory\"] = json.dumps(result[\"predicted_trajectory\"])\n",
+        "    return result"
       ]
     },
     {
@@ -638,7 +642,7 @@
       },
       "outputs": [],
       "source": [
-        "response = agent_parsed_outcome(query=\"Get product details for shoes\")\n",
+        "response = await agent_parsed_outcome(query=\"Get product details for shoes\")\n",
         "display(Markdown(format_output_as_markdown(response)))"
       ]
     },
@@ -650,7 +654,7 @@
       },
       "outputs": [],
       "source": [
-        "response = agent_parsed_outcome(query=\"Get product price for shoes\")\n",
+        "response = await agent_parsed_outcome(query=\"Get product price for shoes\")\n",
         "display(Markdown(format_output_as_markdown(response)))"
       ]
     },
@@ -714,7 +718,7 @@
         "        \"Get product details and price for shoes\",\n",
         "        \"Get product details for speaker?\",\n",
         "    ],\n",
-        "    \"reference_trajectory\": [\n",
+        "    \"predicted_trajectory\": [\n",
         "        [\n",
         "            {\n",
         "                \"tool_name\": \"get_product_price\",\n",
@@ -840,7 +844,7 @@
         ")\n",
         "\n",
         "single_tool_call_eval_result = single_tool_call_eval_task.evaluate(\n",
-        "    runnable=agent_parsed_outcome, experiment_run_name=EXPERIMENT_RUN\n",
+        "    runnable=agent_parsed_outcome_sync, experiment_run_name=EXPERIMENT_RUN\n",
         ")\n",
         "\n",
         "display_eval_report(single_tool_call_eval_result)"
@@ -948,7 +952,7 @@
         ")\n",
         "\n",
         "trajectory_eval_result = trajectory_eval_task.evaluate(\n",
-        "    runnable=agent_parsed_outcome, experiment_run_name=EXPERIMENT_RUN\n",
+        "    runnable=agent_parsed_outcome_sync, experiment_run_name=EXPERIMENT_RUN\n",
         ")\n",
         "\n",
         "display_eval_report(trajectory_eval_result)"
@@ -1055,7 +1059,7 @@
         ")\n",
         "\n",
         "response_eval_result = response_eval_task.evaluate(\n",
-        "    runnable=agent_parsed_outcome, experiment_run_name=EXPERIMENT_RUN\n",
+        "    runnable=agent_parsed_outcome_sync, experiment_run_name=EXPERIMENT_RUN\n",
         ")\n",
         "\n",
         "display_eval_report(response_eval_result)"
@@ -1240,7 +1244,9 @@
         ")\n",
         "\n",
         "response_eval_tool_result = response_eval_tool_task.evaluate(\n",
-        "    runnable=agent_parsed_outcome, experiment_run_name=EXPERIMENT_RUN\n",
+        "    # Uncomment the line below if you are providing the agent with an unparsed dataset\n",
+        "    #runnable=agent_parsed_outcome_sync, \n",
+        "    experiment_run_name=EXPERIMENT_RUN\n",
         ")\n",
         "\n",
         "display_eval_report(response_eval_tool_result)"
@@ -1410,7 +1416,8 @@
         "].apply(json.dumps)\n",
         "byod_eval_sample_dataset[\"reference_trajectory\"] = byod_eval_sample_dataset[\n",
         "    \"reference_trajectory\"\n",
-        "].apply(json.dumps)"
+        "].apply(json.dumps)\n",
+        "byod_eval_sample_dataset[\"response\"] = byod_eval_sample_dataset[\"response\"].apply(json.dumps)"
       ]
     },
     {

llm.txt

@@ -31,9 +31,9 @@ Provides MLOps and infrastructure templates so developers focus on agent logic.
 Establishes production patterns from day one, saving setup time.
 
 ---
-### Section 2: Creating a New Agent Project
+### Section 2: Creating & Enhancing Agent Projects
 
-Start by creating a new agent project from a predefined template. This process supports both interactive and fully automated setup.
+Start by creating a new agent project from a predefined template, or enhance an existing project with agent capabilities. Both processes support interactive and fully automated setup.
 
 **Prerequisites:**
 Before you begin, ensure you have `uv`/`uvx`, `gcloud` CLI, `terraform`, `git`, and `gh` CLI (for automated CI/CD setup) installed and authenticated.
@@ -62,22 +62,30 @@ agent-starter-pack create PROJECT_NAME [OPTIONS]
 ```
 
 **Arguments:**
-*   `PROJECT_NAME`: Name for your new project directory and base for GCP resource naming.
+*   `PROJECT_NAME`: Name for your new project directory and base for GCP resource naming (max 26 chars, converted to lowercase).
 
-**Key Options:**
-*   `-a, --agent`: Agent template (e.g., `adk_base`, `agentic_rag`).
-*   `-d, --deployment-target`: Target deployment environment (`cloud_run` or `agent_engine`).
-*   `--cicd-runner`: CI/CD pipeline runner (`google_cloud_build` or `github_actions`).
-*   `-ds, --datastore`: For RAG agents, the datastore (`vertex_ai_search` or `vertex_ai_vector_search`).
-*   `-i, --include-data-ingestion`: Include data ingestion pipeline scaffolding.
-*   `--session-type`: For agents requiring session management on Cloud Run, specifies the storage type (`in_memory`, `alloydb`, `agent_engine`).
-*   `--region`: GCP region (e.g., `us-central1`).
-*   `--auto-approve`: **Skips all interactive prompts (crucial for automation).**
-*   `--debug`: Enables debug logging during creation.
-*   `--agent-directory, -dir`: Name of the agent directory (overrides template default).
-*   `-o, --output-dir`: Output directory for the project (default: current directory).
-*   `--in-folder, -if`: Template files directly into the current directory instead of creating a new project directory.
-*   `--skip-checks`: Skip verification checks for GCP and Vertex AI.
+**Template Selection:**
+*   `-a, --agent`: Agent template - built-in agents (e.g., `adk_base`, `agentic_rag`), remote templates (`adk@gemini-fullstack`, `github.com/user/repo@branch`), or local projects (`local@./path`).
+
+**Deployment Options:**
+*   `-d, --deployment-target`: Target environment (`cloud_run` or `agent_engine`).
+*   `--cicd-runner`: CI/CD runner (`google_cloud_build` or `github_actions`).
+*   `--region`: GCP region (default: `us-central1`).
+
+**Data & Storage:**
+*   `-i, --include-data-ingestion`: Include data ingestion pipeline.
+*   `-ds, --datastore`: Datastore type (`vertex_ai_search`, `vertex_ai_vector_search`, `alloydb`).
+*   `--session-type`: Session storage (`in_memory`, `alloydb`, `agent_engine`).
+
+**Project Creation:**
+*   `-o, --output-dir`: Output directory (default: current directory).
+*   `--agent-directory, -dir`: Agent code directory name (default: `app`).
+*   `--in-folder`: Create files in current directory instead of new subdirectory.
+
+**Automation:**
+*   `--auto-approve`: **Skip all interactive prompts (crucial for automation).**
+*   `--skip-checks`: Skip GCP/Vertex AI verification checks.
+*   `--debug`: Enable debug logging.
 
 **Automated Creation Example:**
 ```bash
@@ -90,6 +98,35 @@ uvx agent-starter-pack create my-automated-agent \
 
 ---
 
+### `agent-starter-pack enhance` Command
+
+Enhance your existing project with AI agent capabilities by adding agent-starter-pack features in-place. This command supports all the same options as `create` but templates directly into the current directory instead of creating a new project directory.
+
+**Usage:**
+```bash
+agent-starter-pack enhance [TEMPLATE_PATH] [OPTIONS]
+```
+
+**Key Differences from `create`:**
+*   Templates into current directory (equivalent to `create --in-folder`)
+*   `TEMPLATE_PATH` defaults to current directory (`.`)
+*   Project name defaults to current directory name
+*   Additional `--base-template` option to override template inheritance
+
+**Enhanced Project Example:**
+```bash
+# Enhance current directory with agent capabilities
+uvx agent-starter-pack enhance . \
+  --base-template adk_base \
+  -d cloud_run \
+  --region us-central1 \
+  --auto-approve
+```
+
+**Project Structure:** Expects agent code in `app/` directory (configurable via `--agent-directory`).
+
+---
+
 ### Available Agent Templates
 
 Templates for the `create` command (via `-a` or `--agent`):
@@ -208,42 +245,53 @@ For stateful agents, the starter pack supports persistent sessions.
 ---
 
 ### `agent-starter-pack setup-cicd`
-Automates the entire CI/CD setup for a project on GitHub.
+Automates the complete CI/CD infrastructure setup for GitHub-based deployments. Intelligently detects your CI/CD runner (Google Cloud Build or GitHub Actions) and configures everything automatically.
 
 **Usage:**
 ```bash
 uvx agent-starter-pack setup-cicd [OPTIONS]
 ```
-**Prerequisites:** Run from the project root. `uv`, `gh` CLI, `gcloud` CLI, and `terraform` must be installed and authenticated. Requires `Owner` role on the GCP projects.
-
-**Automated CI/CD Setup Options:**
-*   `--staging-project`: (REQUIRED) The Google Cloud Project ID for your staging environment.
-*   `--prod-project`: (REQUIRED) The Google Cloud Project ID for your production environment.
-*   `--repository-name`: (REQUIRED) The name for the new GitHub repository that will be created.
-*   `--repository-owner`: (REQUIRED) Your GitHub username or organization where the repo will be created.
-*   `--auto-approve`: Skips all interactive confirmation prompts.
+
+**Prerequisites:** 
+- Run from the project root (directory with `pyproject.toml`)
+- Required tools: `gh` CLI (authenticated), `gcloud` CLI (authenticated), `terraform`
+- `Owner` role on GCP projects
+- GitHub token with `repo` and `workflow` scopes
+
+**Key Options:**
+*   `--staging-project`, `--prod-project`: GCP project IDs (will prompt if omitted).
+*   `--repository-name`, `--repository-owner`: GitHub repo details (will prompt if omitted).
+*   `--cicd-project`: CI/CD resources project (defaults to prod project).
 *   `--dev-project`: Development project ID (optional).
-*   `--cicd-project`: CICD project ID (defaults to prod project if not specified).
-*   `--region`: GCP region (auto-detects from Terraform vars if not specified).
-*   `--host-connection-name`: Host connection name (optional).
-*   `--github-pat`: GitHub Personal Access Token for programmatic auth.
-*   `--github-app-installation-id`: GitHub App Installation ID for programmatic auth.
-*   `--local-state`: Use local Terraform state instead of remote GCS backend.
+*   `--region`: GCP region (default: `us-central1`).
+*   `--auto-approve`: Skip all interactive prompts.
+*   `--local-state`: Use local Terraform state instead of GCS backend.
 *   `--debug`: Enable debug logging.
-*   `--create-repository`: Flag indicating whether to create a new repository.
 
+**What it does:**
+1. Creates/connects GitHub repository
+2. Sets up Terraform infrastructure with remote state
+3. Configures CI/CD runner connection (Cloud Build or GitHub Actions with WIF)
+4. Provisions staging/prod environments
+5. Sets up local Git repository with origin remote
 
 **Automated Example:**
 ```bash
 uvx agent-starter-pack setup-cicd \
-  --staging-project the-user-staging-project \
-  --prod-project the-user-prod-project \
-  --repository-name the-user-repo-name \
-  --repository-owner the-username \
+  --staging-project your-staging-project \
+  --prod-project your-prod-project \
+  --repository-name your-repo-name \
+  --repository-owner your-username \
   --auto-approve
 ```
-* Note: As a coding agent, you must run this command non-interactively. Before executing, you must ask the user to provide the following required flags: `--staging-project`, `--prod-project`, `--repository-name`, and `--repository-owner`. Once you have these values, you can construct and run the command with the `--auto-approve` flag.
-* Note: If the user tells that `setup-cicd` is not a viable option or it wants to use a different git provider, you must not use this command. Instead, you should look at the `deployment/README.md` to get instructions on how to manually deploy the agent.
+
+**After setup, push to trigger pipeline:**
+```bash
+git add . && git commit -m "Initial commit" && git push -u origin main
+```
+
+* Note: For coding agents - ask user for required project IDs and repo details before running with `--auto-approve`.
+* Note: If user prefers different git provider, refer to `deployment/README.md` for manual deployment.
 ---
 ### Section 6: Operational Guidelines for Coding Agents
 

src/base_template/Makefile

@@ -76,7 +76,7 @@ backend:
 		--region "us-central1" \
 		--no-allow-unauthenticated \
 		--no-cpu-throttling \
-		--labels "created-by=adk" \
+		--labels "created-by=adk{%- if cookiecutter.agent_garden %},deployed-with=agent-garden{%- endif %}" \
 		--set-env-vars \
 		"COMMIT_SHA=$(shell git rev-parse HEAD){%- if cookiecutter.data_ingestion %}{%- if cookiecutter.datastore_type == "vertex_ai_search" %},DATA_STORE_ID={{cookiecutter.project_name}}-datastore,DATA_STORE_REGION=us{%- elif cookiecutter.datastore_type == "vertex_ai_vector_search" %},VECTOR_SEARCH_INDEX={{cookiecutter.project_name}}-vector-search,VECTOR_SEARCH_INDEX_ENDPOINT={{cookiecutter.project_name}}-vector-search-endpoint,VECTOR_SEARCH_BUCKET=$$PROJECT_ID-{{cookiecutter.project_name}}-vs{%- endif %}{%- endif %}" \
 		$(if $(IAP),--iap) \
@@ -98,6 +98,21 @@ local-backend:
 # Start the frontend UI separately for development (requires backend running separately)
 ui:
 	(cd frontend && PORT=8501 npm start)
+
+# Launch dev playground with both frontend and backend hot-reload
+playground-dev:
+	@echo "==============================================================================="
+	@echo "| 🚀 Starting your agent playground in DEV MODE...                           |"
+	@echo "|                                                                             |"
+	@echo "| 🌐 Frontend: http://localhost:8501                                         |"
+	@echo "| 🌐 Backend:  http://localhost:8000                                         |"
+	@echo "| 💡 Try asking: What's the weather in San Francisco?                         |"
+	@echo "| 🔄 Both frontend and backend will auto-reload on changes                    |"
+	@echo "==============================================================================="
+	@echo "Starting backend server..."
+	$(MAKE) local-backend &
+	@echo "Starting frontend dev server..."
+	$(MAKE) ui
 {%- endif %}
 {%- endif %}
 

src/base_template/README.md

@@ -33,7 +33,7 @@ This project is organized as follows:
 ## Requirements
 
 Before you begin, ensure you have:
-- **uv**: Python package manager - [Install](https://docs.astral.sh/uv/getting-started/installation/)
+- **uv**: Python package manager (used for all dependency management in this project) - [Install](https://docs.astral.sh/uv/getting-started/installation/) ([add packages](https://docs.astral.sh/uv/concepts/dependencies/) with `uv add <package>`)
 - **Google Cloud SDK**: For GCP services - [Install](https://cloud.google.com/sdk/docs/install)
 - **Terraform**: For infrastructure deployment - [Install](https://developer.hashicorp.com/terraform/downloads)
 - **make**: Build automation tool - [Install](https://www.gnu.org/software/make/) (pre-installed on most Unix-based systems)

src/cli/commands/create.py

@@ -57,6 +57,13 @@ __all__ = ["create", "shared_template_options"]
 def shared_template_options(f: Callable) -> Callable:
     """Decorator to add shared options for template-based commands."""
     # Apply options in reverse order since decorators are applied bottom-up
+    f = click.option(
+        "-ag",
+        "--agent-garden",
+        is_flag=True,
+        help="Deployed from Agent Garden - customizes welcome messages",
+        default=False,
+    )(f)
     f = click.option(
         "--skip-checks",
         is_flag=True,
@@ -237,6 +244,7 @@ def create(
     skip_checks: bool,
     in_folder: bool,
     agent_directory: str | None,
+    agent_garden: bool = False,
     base_template: str | None = None,
     skip_welcome: bool = False,
     cli_overrides: dict | None = None,
@@ -247,7 +255,7 @@ def create(
 
         # Display welcome banner (unless skipped)
         if not skip_welcome:
-            display_welcome_banner(agent)
+            display_welcome_banner(agent, agent_garden=agent_garden)
         # Validate project name
         if len(project_name) > 26:
             console.print(
@@ -625,6 +633,7 @@ def create(
                     skip_checks=skip_checks,
                     region=region,
                     debug=debug,
+                    agent_garden=agent_garden,
                 )
             except Exception as e:
                 if debug:
@@ -680,6 +689,7 @@ def create(
                 remote_config=config,
                 in_folder=in_folder,
                 cli_overrides=final_cli_overrides,
+                agent_garden=agent_garden,
             )
 
             # Replace region in all files if a different region was specified
@@ -902,7 +912,11 @@ def set_gcp_project(project_id: str, set_quota_project: bool = True) -> None:
 
 
 def setup_gcp_environment(
-    auto_approve: bool, skip_checks: bool, region: str, debug: bool
+    auto_approve: bool,
+    skip_checks: bool,
+    region: str,
+    debug: bool,
+    agent_garden: bool = False,
 ) -> dict:
     """Set up the GCP environment with proper credentials and project.
 
@@ -911,6 +925,7 @@ def setup_gcp_environment(
         skip_checks: Whether to skip verification checks
         region: GCP region for deployment
         debug: Whether debug logging is enabled
+        agent_garden: Whether this deployment is from Agent Garden
 
     Returns:
         Dictionary with credential information
@@ -934,12 +949,16 @@ def setup_gcp_environment(
             console.print("> Skipping Vertex AI connection test", style="yellow")
         else:
             # Test Vertex AI connection
-            _test_vertex_ai_connection(creds_info["project"], region)
+            _test_vertex_ai_connection(
+                creds_info["project"], region, agent_garden=agent_garden
+            )
     else:
         # Even with auto_approve, we should still set the GCP project
         set_gcp_project(creds_info["project"], set_quota_project=True)
         # Test Vertex AI connection
-        _test_vertex_ai_connection(creds_info["project"], region)
+        _test_vertex_ai_connection(
+            creds_info["project"], region, agent_garden=agent_garden
+        )
 
     return creds_info
 
@@ -1027,7 +1046,7 @@ def _handle_credential_verification(creds_info: dict) -> dict:
 
 
 def _test_vertex_ai_connection(
-    project_id: str, region: str, auto_approve: bool = False
+    project_id: str, region: str, auto_approve: bool = False, agent_garden: bool = False
 ) -> None:
     """Test connection to Vertex AI.
 
@@ -1035,13 +1054,16 @@ def _test_vertex_ai_connection(
         project_id: GCP project ID
         region: GCP region for deployment
         auto_approve: Whether to auto-approve API enablement
+        agent_garden: Whether this deployment is from Agent Garden
     """
     console.print("> Testing GCP and Vertex AI Connection...")
     try:
+        context = "agent-garden" if agent_garden else None
         verify_vertex_connection(
             project_id=project_id,
             location=region,
             auto_approve=auto_approve,
+            context=context,
         )
         console.print(
             f"> ✓ Successfully verified connection to Vertex AI in project {project_id}"