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

agent_starter_pack/base_template/{{cookiecutter.agent_directory}}/app_utils/{% if cookiecutter.is_a2a and cookiecutter.agent_name == 'langgraph_base' %}executor{% else %}unused_executor{% endif %}/task_result_aggregator.py

@@ -0,0 +1,152 @@
+# 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.
+
+from __future__ import annotations
+
+from a2a.types import (
+    FilePart,
+    FileWithBytes,
+    FileWithUri,
+    Message,
+    Part,
+    Role,
+    TaskState,
+    TextPart,
+)
+from langchain_core.messages import AIMessage, ToolMessage
+
+
+class LangGraphTaskResultAggregator:
+    """Aggregates streaming LangGraph messages into a final consolidated result."""
+
+    def __init__(self) -> None:
+        self._task_state = TaskState.working
+        self._accumulated_content = ""  # Accumulate text content across chunks
+        self._task_status_message: Message | None = None
+        self._media_parts: list[Part] = []  # Track media parts from tool responses
+
+    def process_message(self, message: AIMessage | ToolMessage) -> None:
+        """Process a streaming message chunk from LangGraph."""
+
+        # Handle tool responses to extract media
+        if isinstance(message, ToolMessage):
+            self._extract_media_from_tool_response(message)
+            return
+
+        if not message.content:
+            return
+
+        if isinstance(message.content, str):
+            self._accumulated_content += message.content
+
+        elif isinstance(message.content, list):
+            for item in message.content:
+                if isinstance(item, str):
+                    self._accumulated_content += item
+                elif isinstance(item, dict) and item.get("type") == "text":
+                    self._accumulated_content += item.get("text", "")
+
+        # Update the task status message with current accumulated content
+        if self._accumulated_content or self._media_parts:
+            parts = []
+            if self._accumulated_content:
+                parts.append(Part(root=TextPart(text=self._accumulated_content)))
+            parts.extend(self._media_parts)
+
+            self._task_status_message = Message(
+                message_id="aggregated",
+                role=Role.agent,
+                parts=parts,
+            )
+
+    def _extract_media_from_tool_response(self, message: ToolMessage) -> None:
+        """Extract media parts from a ToolMessage."""
+
+        if not message.content:
+            return
+
+        if isinstance(message.content, list):
+            for item in message.content:
+                if isinstance(item, dict):
+                    content_type = item.get("type")
+                    if content_type == "image":
+                        self._media_parts.append(
+                            self._convert_media_to_a2a_part(item, "image")
+                        )
+                    elif content_type == "audio":
+                        self._media_parts.append(
+                            self._convert_media_to_a2a_part(item, "audio")
+                        )
+                    elif content_type == "video":
+                        self._media_parts.append(
+                            self._convert_media_to_a2a_part(item, "video")
+                        )
+
+    def _convert_media_to_a2a_part(
+        self, content: dict[str, str], media_type: str
+    ) -> Part:
+        """Convert a media content block to an A2A Part."""
+
+        mime_type = content.get("mime_type")
+
+        if "url" in content:
+            return Part(
+                root=FilePart(file=FileWithUri(uri=content["url"], mime_type=mime_type))
+            )
+        elif "base64" in content:
+            return Part(
+                root=FilePart(
+                    file=FileWithBytes(bytes=content["base64"], mime_type=mime_type)
+                )
+            )
+        elif "file_id" in content:
+            # For now, store file_id as a URI
+            return Part(
+                root=FilePart(
+                    file=FileWithUri(
+                        uri=f"file://{content['file_id']}", mime_type=mime_type
+                    )
+                )
+            )
+
+        # Fallback to empty text part
+        return Part(root=TextPart(text=f"[{media_type} content]"))
+
+    def get_final_parts(self) -> list[Part]:
+        """Get the final consolidated parts for the artifact."""
+
+        parts = []
+        if self._accumulated_content:
+            parts.append(Part(root=TextPart(text=self._accumulated_content)))
+        parts.extend(self._media_parts)
+        return parts if parts else []
+
+    @property
+    def task_state(self) -> TaskState:
+        """Get the current task state."""
+        return self._task_state
+
+    @property
+    def task_status_message(self) -> Message | None:
+        """Get the current task status message with accumulated content."""
+        return self._task_status_message
+
+    def set_failed(self, error_message: str) -> None:
+        """Set the task state to failed."""
+        self._task_state = TaskState.failed
+        self._task_status_message = Message(
+            message_id="error",
+            role=Role.agent,
+            parts=[Part(root=TextPart(text=error_message))],
+        )

agent_starter_pack/cli/commands/create.py

@@ -37,6 +37,7 @@ from ..utils.remote_template import (
     parse_agent_spec,
 )
 from ..utils.template import (
+    add_base_template_dependencies_interactively,
     get_available_agents,
     get_deployment_targets,
     get_template_path,
@@ -81,7 +82,7 @@ def shared_template_options(f: Callable) -> Callable:
     f = click.option("--debug", is_flag=True, help="Enable debug logging")(f)
     f = click.option(
         "--session-type",
-        type=click.Choice(["in_memory", "alloydb", "agent_engine"]),
+        type=click.Choice(["in_memory", "cloud_sql", "agent_engine"]),
         help="Type of session storage to use",
     )(f)
     f = click.option(
@@ -112,6 +113,11 @@ def shared_template_options(f: Callable) -> Callable:
         "-dir",
         help="Name of the agent directory (overrides template default)",
     )(f)
+    f = click.option(
+        "--base-template",
+        "-bt",
+        help="Base template to use (overrides template default, only for remote templates)",
+    )(f)
     return f
 
 
@@ -474,6 +480,18 @@ def create(
             if cli_overrides is None:
                 cli_overrides = {}
             if base_template:
+                # Validate that the base template exists
+                if not validate_base_template(base_template):
+                    available_templates = get_available_base_templates()
+                    console.print(
+                        f"Error: Base template '{base_template}' not found.",
+                        style="bold red",
+                    )
+                    console.print(
+                        f"Available base templates: {', '.join(available_templates)}",
+                        style="yellow",
+                    )
+                    raise click.Abort()
                 cli_overrides["base_template"] = base_template
 
             # Load remote template config
@@ -707,9 +725,9 @@ def create(
         try:
             # Process template (handles both local and remote templates)
             process_template(
-                final_agent,
-                template_path,
-                project_name,
+                agent_name=final_agent,
+                template_dir=template_path,
+                project_name=project_name,
                 deployment_target=final_deployment,
                 cicd_runner=final_cicd_runner,
                 include_data_ingestion=include_data_ingestion,
@@ -727,6 +745,24 @@ def create(
             # Replace region in all files if a different region was specified
             if region != "us-central1":
                 replace_region_in_files(project_path, region, debug=debug)
+
+            # Handle base template dependencies if override was used
+            if base_template and template_source_path and remote_config:
+                # Load base template config to get extra_dependencies
+                base_template_path = get_template_path(base_template, debug=debug)
+                base_config = load_template_config(base_template_path)
+                base_deps = base_config.get("settings", {}).get(
+                    "extra_dependencies", []
+                )
+
+                if base_deps:
+                    # Call interactive dependency addition
+                    add_base_template_dependencies_interactively(
+                        project_path,
+                        base_deps,
+                        base_template,
+                        auto_approve=auto_approve,
+                    )
         finally:
             # Clean up the temporary directory if one was created
             if temp_dir_to_clean:

agent_starter_pack/cli/commands/enhance.py

@@ -225,7 +225,7 @@ def display_agent_directory_selection(
 @click.option(
     "--base-template",
     "-b",
-    help="Base template to inherit from (e.g., adk_base, langgraph_base_react, agentic_rag)",
+    help="Base template to inherit from (e.g., adk_base, langgraph_base, agentic_rag)",
 )
 @click.option(
     "--adk",