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

agent_starter_pack/base_template/{% if cookiecutter.cicd_runner == 'google_cloud_build' %}.cloudbuild{% else %}unused_.cloudbuild{% endif %}/staging.yaml

@@ -39,6 +39,18 @@ steps:
       - 'PATH=/usr/local/bin:/usr/bin:~/.local/bin'
 {%- endif %}
 {%- if cookiecutter.deployment_target == 'cloud_run' %}
+{%- if cookiecutter.is_a2a %}
+  # Extract version from pyproject.toml
+  - name: "gcr.io/cloud-builders/gcloud-slim"
+    id: extract-version
+    entrypoint: /bin/bash
+    args:
+      - "-c"
+      - |
+        VERSION=$(awk -F'"' '/^version = / {print $$2}' pyproject.toml || echo '0.0.0')
+        echo "$${VERSION}" > /workspace/agent_version.txt
+
+{%- endif %}
   # Build and Push
   - name: "gcr.io/cloud-builders/docker"
     args:
@@ -48,6 +60,10 @@ steps:
         "$_REGION-docker.pkg.dev/$PROJECT_ID/$_ARTIFACT_REGISTRY_REPO_NAME/$_CONTAINER_NAME",
         "--build-arg",
         "COMMIT_SHA=$COMMIT_SHA",
+{%- if cookiecutter.is_a2a %}
+        "--build-arg",
+        "AGENT_VERSION=$(cat /workspace/agent_version.txt || echo '0.0.0')",
+{%- endif %}
         ".",
       ]
   - name: "gcr.io/cloud-builders/docker"
@@ -91,6 +107,18 @@ steps:
       - |
         echo $(gcloud auth print-identity-token -q) > id_token.txt
 {%- elif cookiecutter.deployment_target == 'agent_engine' %}
+{%- if cookiecutter.is_a2a %}
+  # Extract version from pyproject.toml
+  - name: "gcr.io/cloud-builders/gcloud-slim"
+    id: extract-version
+    entrypoint: /bin/bash
+    args:
+      - "-c"
+      - |
+        VERSION=$(awk -F'"' '/^version = / {print $$2}' pyproject.toml || echo '0.0.0')
+        echo "$${VERSION}" > /workspace/agent_version.txt
+
+{%- endif %}
   - name: "python:3.12-slim"
     id: install-dependencies
     entrypoint: /bin/bash
@@ -107,12 +135,19 @@ steps:
     args:
       - "-c"
       - |
-        uv export --no-hashes --no-sources --no-header --no-dev --no-emit-project --no-annotate --locked > .requirements.txt
-        uv run {{cookiecutter.agent_directory}}/agent_engine_app.py \
+{%- if cookiecutter.is_a2a %}
+        AGENT_VERSION=$(cat /workspace/agent_version.txt || echo '0.0.0')
+{%- endif %}
+        uv export --no-hashes --no-sources --no-header --no-dev --no-emit-project --no-annotate --locked > {{cookiecutter.agent_directory}}/app_utils/.requirements.txt
+        uv run python -m {{cookiecutter.agent_directory}}.app_utils.deploy \
           --project ${_STAGING_PROJECT_ID} \
           --location ${_REGION} \
-          --artifacts-bucket-name ${_LOGS_BUCKET_NAME_STAGING} \
-          --set-env-vars="COMMIT_SHA=${COMMIT_SHA}{%- if cookiecutter.data_ingestion %}{%- if cookiecutter.datastore_type == "vertex_ai_search" %},DATA_STORE_ID=${_DATA_STORE_ID_STAGING},DATA_STORE_REGION=${_DATA_STORE_REGION}{%- elif cookiecutter.datastore_type == "vertex_ai_vector_search" %},VECTOR_SEARCH_INDEX=${_VECTOR_SEARCH_INDEX_STAGING},VECTOR_SEARCH_INDEX_ENDPOINT=${_VECTOR_SEARCH_INDEX_ENDPOINT_STAGING},VECTOR_SEARCH_BUCKET=${_VECTOR_SEARCH_BUCKET_STAGING}{%- endif %}{%- endif %}"
+          --source-packages=./{{cookiecutter.agent_directory}} \
+          --entrypoint-module={{cookiecutter.agent_directory}}.agent_engine_app \
+          --entrypoint-object=agent_engine \
+          --requirements-file={{cookiecutter.agent_directory}}/app_utils/.requirements.txt \
+          --service-account=${_APP_SERVICE_ACCOUNT_STAGING} \
+          --set-env-vars="COMMIT_SHA=${COMMIT_SHA}{%- if cookiecutter.is_a2a %},AGENT_VERSION=$${AGENT_VERSION}{%- endif %},LOGS_BUCKET_NAME=${_LOGS_BUCKET_NAME_STAGING}{%- if cookiecutter.data_ingestion %}{%- if cookiecutter.datastore_type == "vertex_ai_search" %},DATA_STORE_ID=${_DATA_STORE_ID_STAGING},DATA_STORE_REGION=${_DATA_STORE_REGION}{%- elif cookiecutter.datastore_type == "vertex_ai_vector_search" %},VECTOR_SEARCH_INDEX=${_VECTOR_SEARCH_INDEX_STAGING},VECTOR_SEARCH_INDEX_ENDPOINT=${_VECTOR_SEARCH_INDEX_ENDPOINT_STAGING},VECTOR_SEARCH_BUCKET=${_VECTOR_SEARCH_BUCKET_STAGING}{%- endif %}{%- endif %}"
     env:
       - 'PATH=/usr/local/bin:/usr/bin:~/.local/bin'
 
@@ -175,7 +210,7 @@ steps:
       - |
         export _ID_TOKEN=$(cat id_token.txt)
         export _STAGING_URL=$(cat staging_url.txt)
-        pip install locust==2.31.1 --user
+        pip install locust==2.31.1{%- if cookiecutter.is_a2a %} a2a-sdk~=0.3.9{%- endif %} --user
         locust -f tests/load_test/load_test.py \
         --headless \
         -H $$_STAGING_URL \
@@ -192,7 +227,7 @@ steps:
       - "-c"
       - |
         # Start expose app in remote mode (uses deployment_metadata.json by default)
-        uv run python -m {{cookiecutter.agent_directory}}.utils.expose_app --mode remote &
+        uv run python -m {{cookiecutter.agent_directory}}.app_utils.expose_app --mode remote &
         EXPOSE_PID=$$!
 
         # Wait for expose app to be ready
@@ -243,10 +278,10 @@ steps:
       - "-c"
       - |
         export _TIMESTAMP=$(date +%Y%m%d-%H%M%S)
-        gsutil -m cp -r tests/load_test/.results gs://${_BUCKET_NAME_LOAD_TEST_RESULTS}/results-$${_TIMESTAMP}
+        gsutil -m cp -r tests/load_test/.results gs://${_LOGS_BUCKET_NAME_STAGING}/load-test-results/results-$${_TIMESTAMP}
         echo "_________________________________________________________________________"
-        echo "Load test results copied to gs://${_BUCKET_NAME_LOAD_TEST_RESULTS}/results-$${_TIMESTAMP}"
-        echo "HTTP link: https://console.cloud.google.com/storage/browser/${_BUCKET_NAME_LOAD_TEST_RESULTS}/results-$${_TIMESTAMP}"
+        echo "Load test results copied to gs://${_LOGS_BUCKET_NAME_STAGING}/load-test-results/results-$${_TIMESTAMP}"
+        echo "HTTP link: https://console.cloud.google.com/storage/browser/${_LOGS_BUCKET_NAME_STAGING}/load-test-results/results-$${_TIMESTAMP}"
         echo "_________________________________________________________________________"
 
   # Trigger Prod Deployment

agent_starter_pack/base_template/{{cookiecutter.agent_directory}}/app_utils/telemetry.py

@@ -0,0 +1,96 @@
+# 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 cookiecutter.is_adk %}
+import logging
+import os
+{%- if cookiecutter.is_adk and cookiecutter.is_a2a %}
+
+import google.auth
+from google.adk.cli.adk_web_server import _setup_instrumentation_lib_if_installed
+from google.adk.telemetry.google_cloud import get_gcp_exporters, get_gcp_resource
+from google.adk.telemetry.setup import maybe_set_otel_providers
+{%- endif %}
+
+
+def setup_telemetry() -> str | None:
+    """Configure OpenTelemetry and GenAI telemetry with GCS upload."""
+{%- if cookiecutter.deployment_target == 'agent_engine' %}
+    os.environ.setdefault("GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY", "true")
+{%- endif %}
+
+    bucket = os.environ.get("LOGS_BUCKET_NAME")
+    capture_content = os.environ.get(
+        "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT", "false"
+    )
+    if bucket and capture_content != "false":
+        logging.info("Setting up GenAI telemetry with GCS upload...")
+        os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "NO_CONTENT"
+        os.environ.setdefault("OTEL_INSTRUMENTATION_GENAI_UPLOAD_FORMAT", "jsonl")
+        os.environ.setdefault("OTEL_INSTRUMENTATION_GENAI_COMPLETION_HOOK", "upload")
+        os.environ.setdefault(
+            "OTEL_SEMCONV_STABILITY_OPT_IN", "gen_ai_latest_experimental"
+        )
+        commit_sha = os.environ.get("COMMIT_SHA", "dev")
+        os.environ.setdefault(
+            "OTEL_RESOURCE_ATTRIBUTES",
+            f"service.namespace={{cookiecutter.project_name}},service.version={commit_sha}",
+        )
+        path = os.environ.get("GENAI_TELEMETRY_PATH", "completions")
+        os.environ.setdefault(
+            "OTEL_INSTRUMENTATION_GENAI_UPLOAD_BASE_PATH",
+            f"gs://{bucket}/{path}",
+        )
+{%- if cookiecutter.is_adk and cookiecutter.is_a2a %}
+
+    # Set up OpenTelemetry exporters for Cloud Trace and Cloud Logging
+    credentials, project_id = google.auth.default()
+    otel_hooks = get_gcp_exporters(
+        enable_cloud_tracing=True,
+        enable_cloud_metrics=False,
+        enable_cloud_logging=True,
+        google_auth=(credentials, project_id),
+    )
+    otel_resource = get_gcp_resource(project_id)
+    maybe_set_otel_providers(
+        otel_hooks_to_setup=[otel_hooks],
+        otel_resource=otel_resource,
+    )
+
+    # Set up GenAI SDK instrumentation
+    _setup_instrumentation_lib_if_installed()
+{%- endif %}
+
+    return bucket
+{%- else %}
+import logging
+
+from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
+
+
+def setup_telemetry() -> None:
+    """Initialize Traceloop telemetry for LangGraph agents."""
+    try:
+        from traceloop.sdk import Instruments, Traceloop
+
+        Traceloop.init(
+            app_name="{{cookiecutter.project_name}}",
+            disable_batch=False,
+            telemetry_enabled=False,
+            exporter=CloudTraceSpanExporter(),
+            instruments={Instruments.LANGCHAIN},
+        )
+    except Exception as e:
+        logging.error("Failed to initialize Telemetry: %s", str(e))
+{%- endif %}

agent_starter_pack/base_template/{{cookiecutter.agent_directory}}/{utils → app_utils}/typing.py

@@ -26,12 +26,14 @@ from pydantic import (
     Field,
 )
 {%- else %}
+import uuid
 from typing import (
     Literal,
 )
 
 from pydantic import (
     BaseModel,
+    Field,
 )
 {%- endif %}
 {%- else %}
@@ -103,14 +105,10 @@ class Feedback(BaseModel):
 
     score: int | float
     text: str | None = ""
-{%- if cookiecutter.is_adk %}
-    invocation_id: str
-{%- else %}
-    run_id: str
-{%- endif %}
     log_type: Literal["feedback"] = "feedback"
     service_name: Literal["{{cookiecutter.project_name}}"] = "{{cookiecutter.project_name}}"
-    user_id: str = ""
+    user_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    session_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
 {% if not cookiecutter.is_adk %}
 
 def ensure_valid_config(config: RunnableConfig | None) -> RunnableConfig:

agent_starter_pack/{agents/crewai_coding_crew/app/crew/config/agents.yaml → base_template/{{cookiecutter.agent_directory}}/app_utils/{% if cookiecutter.is_a2a and cookiecutter.agent_name == 'langgraph_base' %}converters{% else %}unused_converters{% endif %}/__init__.py }

@@ -12,28 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-senior_engineer_agent:
-  role: >
-    Senior Software Engineer
+"""Converters for A2A and LangChain types."""
 
+from .part_converter import (
+    convert_a2a_parts_to_langchain_content,
+    convert_langchain_content_to_a2a_parts,
+)
 
-  goal: >
-    Create software as needed
-
-
-  backstory: >
-    You are a Senior Software Engineer at a leading tech company. You are an expert Python programmer and do your best to produce perfect code.
-
-
-chief_qa_engineer_agent:
-  role: >
-    Chief Software Quality Control Engineer
-
-
-  goal: >
-    Ensure that the code does the job that it is supposed to do and that it is error free.
-
-
-  backstory: >
-    You feel that programmers always do only half the job, so you are super dedicate to make high quality code.
-
+__all__ = [
+    "convert_a2a_parts_to_langchain_content",
+    "convert_langchain_content_to_a2a_parts",
+]

agent_starter_pack/base_template/{{cookiecutter.agent_directory}}/app_utils/{% if cookiecutter.is_a2a and cookiecutter.agent_name == 'langgraph_base' %}converters{% else %}unused_converters{% endif %}/part_converter.py

@@ -0,0 +1,138 @@
+# 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.
+
+"""Converters between A2A Parts and LangChain message content."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from a2a.types import FilePart, FileWithBytes, FileWithUri, Part, TextPart
+
+logger = logging.getLogger(__name__)
+
+
+LangChainContent = str | list[str | dict[str, Any]]
+LangChainContentDict = dict[str, Any]
+
+
+def convert_a2a_part_to_langchain_content(part: Part) -> LangChainContentDict | str:
+    """Convert an A2A Part to LangChain message content format."""
+
+    root = part.root
+
+    if isinstance(root, TextPart):
+        return {"type": "text", "text": root.text}
+
+    elif isinstance(root, FilePart):
+        file_data = root.file
+        mime_type = file_data.mime_type if hasattr(file_data, "mime_type") else None
+
+        # Determine media type from mime_type
+        media_type = "image"  # default
+        if mime_type:
+            if mime_type.startswith("audio/"):
+                media_type = "audio"
+            elif mime_type.startswith("video/"):
+                media_type = "video"
+
+        if isinstance(file_data, FileWithUri):
+            return {"type": media_type, "url": file_data.uri}
+        else:
+            # Base64 data should already be encoded
+            return {
+                "type": media_type,
+                "base64": file_data.bytes,
+                "mime_type": mime_type or "application/octet-stream",
+            }
+
+    else:
+        import json
+
+        data_str = json.dumps(root.data, indent=2)
+        return {"type": "text", "text": f"[Structured Data]\n{data_str}"}
+
+
+def convert_langchain_content_to_a2a_part(content: Any) -> Part:
+    """Convert LangChain message content to an A2A Part."""
+
+    if isinstance(content, str):
+        return Part(root=TextPart(text=content))
+
+    if isinstance(content, dict):
+        content_type = content.get("type")
+
+        if content_type == "text":
+            text = content.get("text", "")
+            return Part(root=TextPart(text=text))
+
+        elif content_type in ("image", "audio", "video"):
+            # Handle URL-based media
+            if "url" in content:
+                return Part(root=FilePart(file=FileWithUri(uri=content["url"])))
+
+            # Handle base64-encoded media
+            elif "base64" in content:
+                mime_type = content.get("mime_type")
+                return Part(
+                    root=FilePart(
+                        file=FileWithBytes(bytes=content["base64"], mime_type=mime_type)
+                    )
+                )
+
+            # Handle file_id-based media
+            elif "file_id" in content:
+                return Part(
+                    root=FilePart(file=FileWithUri(uri=f"file://{content['file_id']}"))
+                )
+
+        else:
+            import json
+
+            text = json.dumps(content)
+            logger.warning(f"Unknown content type '{content_type}', converting to text")
+            return Part(root=TextPart(text=text))
+
+    logger.warning(f"Unknown content type: {type(content)}, converting to text")
+    return Part(root=TextPart(text=str(content)))
+
+
+def convert_a2a_parts_to_langchain_content(parts: list[Part]) -> LangChainContent:
+    """Convert a list of A2A Parts to LangChain message content."""
+
+    if not parts:
+        return ""
+
+    converted: list[str | dict[str, Any]] = []
+    for part in parts:
+        result = convert_a2a_part_to_langchain_content(part)
+        converted.append(result)
+
+    if len(converted) == 1 and isinstance(converted[0], str):
+        return converted[0]
+
+    return converted
+
+
+def convert_langchain_content_to_a2a_parts(content: LangChainContent) -> list[Part]:
+    """Convert LangChain message content to a list of A2A Parts."""
+
+    if isinstance(content, str):
+        return [Part(root=TextPart(text=content))]
+
+    result: list[Part] = []
+    for item in content:
+        result.append(convert_langchain_content_to_a2a_part(item))
+    return result

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 %}/__init__.py

@@ -0,0 +1,13 @@
+# 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.

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 %}/a2a_agent_executor.py

@@ -0,0 +1,265 @@
+# 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
+
+import logging
+import uuid
+from datetime import datetime, timezone
+
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.types import (
+    Artifact,
+    Message,
+    Part,
+    Role,
+    TaskArtifactUpdateEvent,
+    TaskState,
+    TaskStatus,
+    TaskStatusUpdateEvent,
+    TextPart,
+    UnsupportedOperationError,
+)
+from a2a.utils.errors import ServerError
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from langgraph.graph.state import CompiledStateGraph
+from pydantic import BaseModel
+from typing_extensions import override
+
+from ..converters import (
+    convert_a2a_parts_to_langchain_content,
+    convert_langchain_content_to_a2a_parts,
+)
+from .task_result_aggregator import LangGraphTaskResultAggregator
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class LangGraphAgentExecutorConfig(BaseModel):
+    """Configuration for the LangGraphAgentExecutor."""
+
+    enable_streaming: bool = True
+
+
+class LangGraphAgentExecutor(AgentExecutor):
+    """An AgentExecutor that runs a LangGraph agent against an A2A request and
+    publishes updates to an event queue."""
+
+    def __init__(
+        self,
+        *,
+        graph: CompiledStateGraph,
+        config: LangGraphAgentExecutorConfig | None = None,
+    ):
+        super().__init__()
+        self._graph = graph
+        self._config = config or LangGraphAgentExecutorConfig()
+
+    @override
+    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+        """Cancel the execution."""
+        # TODO: Implement proper cancellation logic if needed
+        raise ServerError(error=UnsupportedOperationError())
+
+    @override
+    async def execute(
+        self,
+        context: RequestContext,
+        event_queue: EventQueue,
+    ) -> None:
+        """Executes an A2A request and publishes updates to the event queue."""
+
+        if not context.message:
+            raise ValueError("A2A request must have a message")
+
+        if not context.task_id:
+            raise ValueError("task_id is required")
+        if not context.context_id:
+            raise ValueError("context_id is required")
+
+        task_id = context.task_id
+        context_id = context.context_id
+
+        if not context.current_task:
+            await event_queue.enqueue_event(
+                TaskStatusUpdateEvent(
+                    task_id=task_id,
+                    status=TaskStatus(
+                        state=TaskState.submitted,
+                        message=context.message,
+                        timestamp=datetime.now(timezone.utc).isoformat(),
+                    ),
+                    context_id=context_id,
+                    final=False,
+                )
+            )
+
+        try:
+            await self._handle_request(context, event_queue)
+        except Exception as e:
+            logger.error("Error handling A2A request: %s", e, exc_info=True)
+            try:
+                await event_queue.enqueue_event(
+                    TaskStatusUpdateEvent(
+                        task_id=task_id,
+                        status=TaskStatus(
+                            state=TaskState.failed,
+                            timestamp=datetime.now(timezone.utc).isoformat(),
+                            message=Message(
+                                message_id=str(uuid.uuid4()),
+                                role=Role.agent,
+                                parts=[Part(root=TextPart(text=str(e)))],
+                            ),
+                        ),
+                        context_id=context_id,
+                        final=True,
+                    )
+                )
+            except Exception as enqueue_error:
+                logger.error(
+                    "Failed to publish failure event: %s", enqueue_error, exc_info=True
+                )
+
+    async def _handle_request(
+        self,
+        context: RequestContext,
+        event_queue: EventQueue,
+    ) -> None:
+        """Handle the A2A request and publish events."""
+
+        graph = self._graph
+
+        if not context.task_id:
+            raise ValueError("task_id is required")
+        if not context.context_id:
+            raise ValueError("context_id is required")
+
+        task_id = context.task_id
+        context_id = context.context_id
+
+        await event_queue.enqueue_event(
+            TaskStatusUpdateEvent(
+                task_id=task_id,
+                status=TaskStatus(
+                    state=TaskState.working,
+                    timestamp=datetime.now(timezone.utc).isoformat(),
+                ),
+                context_id=context_id,
+                final=False,
+            )
+        )
+
+        # Convert A2A message parts to LangChain content
+        message_content = (
+            convert_a2a_parts_to_langchain_content(context.message.parts)
+            if context.message
+            else ""
+        )
+        messages = [HumanMessage(content=message_content)]
+        input_dict = {"messages": messages}
+
+        task_result_aggregator = LangGraphTaskResultAggregator()
+
+        try:
+            if self._config.enable_streaming:
+                async for chunk in graph.astream(input_dict, stream_mode="messages"):
+                    if isinstance(chunk, tuple) and len(chunk) > 0:
+                        message = chunk[0]
+
+                        # Process AIMessage chunks
+                        if isinstance(message, AIMessage) and message.content:
+                            task_result_aggregator.process_message(message)
+
+                            parts = convert_langchain_content_to_a2a_parts(
+                                message.content
+                            )
+                            await event_queue.enqueue_event(
+                                TaskStatusUpdateEvent(
+                                    task_id=task_id,
+                                    status=TaskStatus(
+                                        state=TaskState.working,
+                                        timestamp=datetime.now(
+                                            timezone.utc
+                                        ).isoformat(),
+                                        message=Message(
+                                            message_id=str(uuid.uuid4()),
+                                            role=Role.agent,
+                                            parts=parts,
+                                        ),
+                                    ),
+                                    context_id=context_id,
+                                    final=False,
+                                )
+                            )
+
+                        # Process ToolMessage chunks (for multimodal content)
+                        elif isinstance(message, ToolMessage):
+                            task_result_aggregator.process_message(message)
+            else:
+                result = await graph.ainvoke(input_dict)
+                if "messages" in result:
+                    for msg in result["messages"]:
+                        if isinstance(msg, (AIMessage, ToolMessage)) and msg.content:
+                            task_result_aggregator.process_message(msg)
+            if (
+                task_result_aggregator.task_state == TaskState.working
+                and task_result_aggregator.task_status_message is not None
+                and task_result_aggregator.task_status_message.parts
+            ):
+                # Publish the artifact update event as the final result
+                await event_queue.enqueue_event(
+                    TaskArtifactUpdateEvent(
+                        task_id=task_id,
+                        last_chunk=True,
+                        context_id=context_id,
+                        artifact=Artifact(
+                            artifact_id=str(uuid.uuid4()),
+                            parts=task_result_aggregator.get_final_parts(),
+                        ),
+                    )
+                )
+                # Publish the final status update event
+                await event_queue.enqueue_event(
+                    TaskStatusUpdateEvent(
+                        task_id=task_id,
+                        status=TaskStatus(
+                            state=TaskState.completed,
+                            timestamp=datetime.now(timezone.utc).isoformat(),
+                        ),
+                        context_id=context_id,
+                        final=True,
+                    )
+                )
+            else:
+                # Publish final status with current task_state and message
+                await event_queue.enqueue_event(
+                    TaskStatusUpdateEvent(
+                        task_id=task_id,
+                        status=TaskStatus(
+                            state=task_result_aggregator.task_state,
+                            timestamp=datetime.now(timezone.utc).isoformat(),
+                            message=task_result_aggregator.task_status_message,
+                        ),
+                        context_id=context_id,
+                        final=True,
+                    )
+                )
+
+        except Exception as e:
+            logger.error("Error during graph execution: %s", e, exc_info=True)
+            # Update task state to failed using aggregator
+            task_result_aggregator.set_failed(str(e))
+            raise