agent-starter-pack 0.19.0__tar.gz → 0.19.2__tar.gz

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/.claude/settings.local.json

@@ -37,7 +37,8 @@
       "Bash(terraform plan -var-file=vars/env.tfvars)",
       "Bash(uv run pytest \"tests/unit/test_makefile_template.py::TestMakefileGeneration::test_makefile_hash[adk_base_agent_engine_no_data]\" -v)",
       "Bash(git add:*)",
-      "Bash(git commit:*)"
+      "Bash(git commit:*)",
+      "Read(//private/tmp/asp-test/test-labels-check/rag/**)"
     ],
     "deny": [],
     "ask": []

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-starter-pack
-Version: 0.19.0
+Version: 0.19.2
 Summary: CLI to bootstrap production-ready Google Cloud GenAI agent projects from templates.
 Author-email: Google LLC <agent-starter-pack@google.com>
 License: Apache-2.0

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/agent_starter_pack/agents/adk_a2a_base/notebooks/adk_a2a_app_testing.ipynb

@@ -503,7 +503,7 @@
     "\n",
     "# Send the streaming request to the A2A endpoint\n",
     "response = requests.post(\n",
-    "    f\"{SERVICE_URL}/a2a/app/\",\n",
+    "    f\"{SERVICE_URL}/a2a/app\",\n",
     "    headers=headers,\n",
     "    json=request.model_dump(mode=\"json\", exclude_none=True),\n",
     "    stream=True,\n",
@@ -556,7 +556,7 @@
     "\n",
     "# Send the streaming request to the local A2A endpoint\n",
     "response = requests.post(\n",
-    "    \"http://127.0.0.1:8000/a2a/app/\",\n",
+    "    \"http://127.0.0.1:8000/a2a/app\",\n",
     "    headers=headers,\n",
     "    json=request.model_dump(mode=\"json\", exclude_none=True),\n",
     "    stream=True,\n",

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/agent_starter_pack/cli/utils/template.py

@@ -17,6 +17,7 @@ import logging
 import os
 import pathlib
 import shutil
+import sys
 import tempfile
 from dataclasses import dataclass
 from typing import Any
@@ -459,6 +460,72 @@ 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 process_template(
     agent_name: str,
     template_dir: pathlib.Path,
@@ -560,13 +627,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"
@@ -718,14 +781,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,
@@ -779,8 +842,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(
@@ -929,8 +992,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(
@@ -1091,13 +1158,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:

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/agent_starter_pack/deployment_targets/cloud_run/tests/load_test/load_test.py

@@ -163,7 +163,7 @@ from locust import HttpUser, between, task
 {%- endif %}
 {%- if cookiecutter.is_adk_a2a %}
 
-ENDPOINT = "/a2a/{{cookiecutter.agent_directory}}/"
+ENDPOINT = "/a2a/{{cookiecutter.agent_directory}}"
 {%- elif cookiecutter.is_adk %}
 
 ENDPOINT = "/run_sse"

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/agent_starter_pack/deployment_targets/cloud_run/{{cookiecutter.agent_directory}}/server.py

@@ -302,6 +302,10 @@ from a2a.server.apps import A2AFastAPIApplication
 from a2a.server.request_handlers import DefaultRequestHandler
 from a2a.server.tasks import InMemoryTaskStore
 from a2a.types import AgentCapabilities, AgentCard
+from a2a.utils.constants import (
+    AGENT_CARD_WELL_KNOWN_PATH,
+    EXTENDED_AGENT_CARD_PATH,
+)
 {%- endif %}
 from fastapi import FastAPI
 {%- if cookiecutter.is_adk_a2a %}
@@ -358,13 +362,15 @@ request_handler = DefaultRequestHandler(
     agent_executor=A2aAgentExecutor(runner=runner), task_store=InMemoryTaskStore()
 )
 
+A2A_RPC_PATH = f"/a2a/{adk_app.name}"
+
 
 async def build_dynamic_agent_card() -> AgentCard:
     """Builds the Agent Card dynamically from the root_agent."""
     agent_card_builder = AgentCardBuilder(
         agent=adk_app.root_agent,
         capabilities=AgentCapabilities(streaming=True),
-        rpc_url=f"{os.getenv('APP_URL', 'http://0.0.0.0:8000')}/a2a/{adk_app.name}/",
+        rpc_url=f"{os.getenv('APP_URL', 'http://0.0.0.0:8000')}{A2A_RPC_PATH}",
         agent_version=os.getenv("AGENT_VERSION", "0.1.0"),
     )
     agent_card = await agent_card_builder.build()
@@ -374,10 +380,13 @@ async def build_dynamic_agent_card() -> AgentCard:
 @asynccontextmanager
 async def lifespan(app_instance: FastAPI) -> AsyncIterator[None]:
     agent_card = await build_dynamic_agent_card()
-    a2a_app = A2AFastAPIApplication(
-        agent_card=agent_card, http_handler=request_handler
-    ).build()
-    app_instance.mount(f"/a2a/{adk_app.name}", a2a_app)
+    a2a_app = A2AFastAPIApplication(agent_card=agent_card, http_handler=request_handler)
+    a2a_app.add_routes_to_app(
+        app_instance,
+        agent_card_url=f"{A2A_RPC_PATH}{AGENT_CARD_WELL_KNOWN_PATH}",
+        rpc_url=A2A_RPC_PATH,
+        extended_agent_card_url=f"{A2A_RPC_PATH}{EXTENDED_AGENT_CARD_PATH}",
+    )
     yield
 
 

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/docs/.vitepress/config.js

@@ -63,7 +63,7 @@ export default defineConfig({
       { text: 'Guide', link: '/guide/getting-started' },
       { text: 'Remote Templates', link: '/remote-templates/' },
       { text: 'Agents', link: '/agents/overview' },
-      { text: 'CLI', link: '/cli/index.md' },
+      { text: 'CLI', link: '/cli' },
       { text: 'Community', link: '/guide/community-showcase' }
     ],
     sidebar: [

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-starter-pack"
-version = "0.19.0"
+version = "0.19.2"
 description = "CLI to bootstrap production-ready Google Cloud GenAI agent projects from templates."
 authors = [
     { name = "Google LLC", email = "agent-starter-pack@google.com" },

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/tests/cli/utils/test_remote_template.py

@@ -30,6 +30,7 @@ from agent_starter_pack.cli.utils.remote_template import (
     parse_agent_starter_pack_version_from_lock,
     render_and_merge_makefiles,
 )
+from agent_starter_pack.cli.utils.template import _extract_agent_garden_labels
 
 
 class TestRemoteTemplateSpec:
@@ -1047,3 +1048,99 @@ class TestCheckAndExecuteWithVersionLock:
 
         write_call = write_calls[0][0][0]
         assert "installing test_project" in write_call
+
+
+class TestAgentGardenLabelExtraction:
+    """Test the logic for extracting agent_garden labels."""
+
+    def test_extract_from_remote_spec_adk_samples(self) -> None:
+        """Test extracting labels from remote_spec when is_adk_samples=True."""
+        remote_spec = RemoteTemplateSpec(
+            repo_url="https://github.com/google/adk-samples",
+            template_path="python/agents/RAG",
+            git_ref="main",
+            is_adk_samples=True,
+        )
+
+        agent_sample_id, agent_sample_publisher = _extract_agent_garden_labels(
+            agent_garden=True,
+            remote_spec=remote_spec,
+            remote_template_path=None,
+        )
+
+        assert agent_sample_id == "RAG"
+        assert agent_sample_publisher == "google"
+
+    def test_extract_from_pyproject_toml(self) -> None:
+        """Test extracting labels from pyproject.toml fallback."""
+        import sys
+
+        remote_template_path = pathlib.Path("/test/template")
+
+        pyproject_content = b"""
+[project]
+name = "rag"
+version = "0.1.0"
+"""
+
+        # Mock the toml data that would be loaded
+        mock_toml_data = {"project": {"name": "rag", "version": "0.1.0"}}
+
+        # Determine which toml library to mock based on Python version
+        if sys.version_info >= (3, 11):
+            toml_module = "tomllib"
+        else:
+            toml_module = "tomli"
+
+        with (
+            patch("pathlib.Path.exists", return_value=True),
+            patch("builtins.open", mock_open(read_data=pyproject_content)),
+            patch(f"{toml_module}.load") as mock_toml_load,
+        ):
+            mock_toml_load.return_value = mock_toml_data
+
+            agent_sample_id, agent_sample_publisher = _extract_agent_garden_labels(
+                agent_garden=True,
+                remote_spec=None,
+                remote_template_path=remote_template_path,
+            )
+
+        assert agent_sample_id == "rag"
+        assert agent_sample_publisher == "google"
+
+    def test_no_labels_when_agent_garden_false(self) -> None:
+        """Test that labels are not set when agent_garden=False."""
+        remote_spec = RemoteTemplateSpec(
+            repo_url="https://github.com/google/adk-samples",
+            template_path="python/agents/RAG",
+            git_ref="main",
+            is_adk_samples=True,
+        )
+
+        agent_sample_id, agent_sample_publisher = _extract_agent_garden_labels(
+            agent_garden=False,
+            remote_spec=remote_spec,
+            remote_template_path=None,
+        )
+
+        # Labels should remain None when agent_garden=False
+        assert agent_sample_id is None
+        assert agent_sample_publisher is None
+
+    def test_no_labels_when_no_pyproject_toml(self) -> None:
+        """Test that labels remain empty when pyproject.toml doesn't exist."""
+        remote_template_path = pathlib.Path("/test/template")
+
+        with patch("pathlib.Path.exists", return_value=False):
+            agent_sample_id, agent_sample_publisher = _extract_agent_garden_labels(
+                agent_garden=True,
+                remote_spec=None,
+                remote_template_path=remote_template_path,
+            )
+
+        assert agent_sample_id is None
+        assert agent_sample_publisher is None
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

{agent_starter_pack-0.19.0 → agent_starter_pack-0.19.2}/uv.lock

@@ -11,7 +11,7 @@ resolution-markers = [
 
 [[package]]
 name = "agent-starter-pack"
-version = "0.19.0"
+version = "0.19.2"
 source = { editable = "." }
 dependencies = [
     { name = "backoff" },