agentex-sdk 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

agentex/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "agentex"
-__version__ = "0.2.3"  # x-release-please-version
+__version__ = "0.2.5"  # x-release-please-version

agentex/lib/adk/_modules/acp.py

@@ -4,6 +4,7 @@ from typing import Any
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.services.adk.acp.acp import ACPService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.acp.acp_activities import (
@@ -40,7 +41,7 @@ class ACPModule:
             acp_activities (Optional[ACPActivities]): Optional pre-configured ACP activities. If None, will be auto-initialized.
         """
         if acp_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._acp_service = ACPService(agentex_client=agentex_client, tracer=tracer)
         else:

agentex/lib/adk/_modules/agent_task_tracker.py

@@ -3,6 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.services.adk.agent_task_tracker import AgentTaskTrackerService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.agent_task_tracker_activities import (
@@ -33,7 +34,7 @@ class AgentTaskTrackerModule:
         agent_task_tracker_service: AgentTaskTrackerService | None = None,
     ):
         if agent_task_tracker_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._agent_task_tracker_service = AgentTaskTrackerService(
                 agentex_client=agentex_client, tracer=tracer

agentex/lib/adk/_modules/agents.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
 from typing import Optional
 
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.temporal.activities.adk.agents_activities import AgentsActivityName, GetAgentParams
 from temporalio.common import RetryPolicy
 
@@ -28,7 +29,7 @@ class AgentsModule:
         agents_service: Optional[AgentsService] = None,
     ):
         if agents_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._agents_service = AgentsService(agentex_client=agentex_client, tracer=tracer)
         else:

agentex/lib/adk/_modules/events.py

@@ -3,6 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.services.adk.events import EventsService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.events_activities import (
@@ -32,7 +33,7 @@ class EventsModule:
         events_service: EventsService | None = None,
     ):
         if events_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._events_service = EventsService(
                 agentex_client=agentex_client, tracer=tracer

agentex/lib/adk/_modules/messages.py

@@ -3,6 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.messages import MessagesService
 from agentex.lib.core.services.adk.streaming import StreamingService
@@ -37,7 +38,7 @@ class MessagesModule:
         messages_service: MessagesService | None = None,
     ):
         if messages_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,

agentex/lib/adk/_modules/state.py

@@ -5,6 +5,7 @@ from pydantic import BaseModel
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.services.adk.state import StateService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.state_activities import (
@@ -36,7 +37,7 @@ class StateModule:
         state_service: StateService | None = None,
     ):
         if state_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._state_service = StateService(
                 agentex_client=agentex_client, tracer=tracer

agentex/lib/adk/_modules/streaming.py

@@ -1,6 +1,7 @@
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.streaming import (
     StreamingService,
@@ -34,7 +35,7 @@ class StreamingModule:
         """
         if streaming_service is None:
             stream_repository = RedisStreamRepository()
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             self._streaming_service = StreamingService(
                 agentex_client=agentex_client,
                 stream_repository=stream_repository,

agentex/lib/adk/_modules/tasks.py

@@ -3,6 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.services.adk.tasks import TasksService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.tasks_activities import (
@@ -31,7 +32,7 @@ class TasksModule:
         tasks_service: TasksService | None = None,
     ):
         if tasks_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._tasks_service = TasksService(
                 agentex_client=agentex_client, tracer=tracer

agentex/lib/adk/_modules/tracing.py

@@ -6,6 +6,7 @@ from typing import Any
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
+from agentex.lib.adk.utils._modules.client import get_async_agentex_client
 from agentex.lib.core.services.adk.tracing import TracingService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.tracing_activities import (
@@ -38,7 +39,7 @@ class TracingModule:
             tracing_activities (Optional[TracingActivities]): Optional pre-configured tracing activities. If None, will be auto-initialized.
         """
         if tracing_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = get_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._tracing_service = TracingService(tracer=tracer)
         else:

agentex/lib/adk/utils/_modules/client.py

@@ -0,0 +1,43 @@
+import threading
+from typing import Dict, Optional, Any
+
+from agentex import AsyncAgentex
+from agentex.lib.environment_variables import EnvironmentVariables, refreshed_environment_variables
+
+_client: Optional["AsyncAgentex"] = None
+_cached_headers: Dict[str, str] = {}
+_init_kwargs: Dict[str, Any] = {}
+_lock = threading.RLock()
+
+
+def _build_headers() -> Dict[str, str]:
+    EnvironmentVariables.refresh()
+    if refreshed_environment_variables and getattr(refreshed_environment_variables, "AGENT_ID", None):
+        return {"x-agent-identity": refreshed_environment_variables.AGENT_ID}
+    return {}
+
+
+def get_async_agentex_client(**kwargs) -> "AsyncAgentex":
+    """
+    Return a cached AsyncAgentex instance (created synchronously).
+    Each call re-checks env vars and updates client.default_headers if needed.
+    """
+    global _client, _cached_headers, _init_kwargs
+
+    new_headers = _build_headers()
+
+    with _lock:
+        # First time (or kwargs changed) -> build a new client
+        if _client is None or kwargs != _init_kwargs:
+            _client = AsyncAgentex(default_headers=new_headers.copy(), **kwargs)
+            _cached_headers = new_headers
+            _init_kwargs = dict(kwargs)
+            return _client
+
+        # Same client; maybe headers changed
+        if new_headers != _cached_headers:
+            _cached_headers = new_headers
+            _client.default_headers.clear()
+            _client.default_headers.update(new_headers)
+
+        return _client

agentex/lib/cli/commands/agents.py

@@ -141,13 +141,13 @@ def build(
         typer.echo("No registry provided, skipping image build")
         return
 
-    platform_list = platforms.split(",") if platforms else []
+    platform_list = platforms.split(",") if platforms else ["linux/amd64"]
 
     try:
         image_url = build_agent(
             manifest_path=manifest,
-            registry_url=registry,  # Now guaranteed to be non-None
-            repository_name=repository_name or "default-repo",  # Provide default
+            registry_url=registry,
+            repository_name=repository_name,
             platforms=platform_list,
             push=push,
             secret=secret or "",  # Provide default empty string

agentex/lib/cli/handlers/agent_handlers.py

@@ -21,7 +21,7 @@ class DockerBuildError(Exception):
 def build_agent(
     manifest_path: str,
     registry_url: str,
-    repository_name: str,
+    repository_name: str | None,
     platforms: list[str],
     push: bool = False,
     secret: str = None,

agentex/lib/cli/handlers/cleanup_handlers.py

@@ -168,19 +168,13 @@ def cleanup_single_task(client: Agentex, agent_name: str, task_id: str) -> None:
     """
     try:
         # Use the agent RPC method to cancel the task
-        try:
-            client.agents.rpc_by_name(
-                agent_name=agent_name,
-                method="task/cancel",
-                params={"task_id": task_id}
-            )
-            logger.debug(f"Successfully cancelled task {task_id} via agent '{agent_name}'")
-        except Exception as e:
-            # If RPC cancel fails, try direct task deletion as fallback
-            logger.warning(f"RPC task/cancel failed for task {task_id}, trying direct deletion: {e}")
-            client.tasks.delete(task_id=task_id)
-            logger.debug(f"Successfully deleted task {task_id} directly")
-        
+        client.agents.rpc_by_name(
+            agent_name=agent_name,
+            method="task/cancel",
+            params={"task_id": task_id}
+        )
+        logger.debug(f"Successfully cancelled task {task_id} via agent '{agent_name}'")
+    
     except Exception as e:
-        logger.warning(f"Failed to cleanup task {task_id}: {e}")
-        raise 
+        logger.warning(f"RPC task/cancel failed for task {task_id}: {e}")
+        raise

agentex/lib/cli/handlers/deploy_handlers.py

@@ -11,6 +11,7 @@ from rich.console import Console
 from agentex.lib.cli.utils.auth_utils import _encode_principal_context
 from agentex.lib.cli.utils.exceptions import DeploymentError, HelmError
 from agentex.lib.cli.utils.kubectl_utils import check_and_switch_cluster_context
+from agentex.lib.cli.utils.path_utils import calculate_docker_acp_module, PathResolutionError
 from agentex.lib.environment_variables import EnvVarKeys
 from agentex.lib.sdk.config.agent_config import AgentConfig
 from agentex.lib.sdk.config.agent_manifest import AgentManifest
@@ -100,10 +101,24 @@ def convert_env_vars_dict_to_list(env_vars: dict[str, str]) -> list[dict[str, st
     return [{"name": key, "value": value} for key, value in env_vars.items()]
 
 
+def add_acp_command_to_helm_values(helm_values: dict[str, Any], manifest: AgentManifest, manifest_path: str) -> None:
+    """Add dynamic ACP command to helm values based on manifest configuration"""
+    try:
+        docker_acp_module = calculate_docker_acp_module(manifest, manifest_path)
+        # Create the uvicorn command with the correct module path
+        helm_values["command"] = ["uvicorn", f"{docker_acp_module}:acp", "--host", "0.0.0.0", "--port", "8000"]
+        logger.info(f"Using dynamic ACP command: uvicorn {docker_acp_module}:acp")
+    except (PathResolutionError, Exception) as e:
+        # Fallback to default command structure
+        logger.warning(f"Could not calculate dynamic ACP module ({e}), using default: project.acp")
+        helm_values["command"] = ["uvicorn", "project.acp:acp", "--host", "0.0.0.0", "--port", "8000"]
+
+
 def merge_deployment_configs(
     manifest: AgentManifest,
     cluster_config: ClusterConfig | None,
     deploy_overrides: InputDeployOverrides,
+    manifest_path: str,
 ) -> dict[str, Any]:
     agent_config: AgentConfig = manifest.agent
 
@@ -176,9 +191,12 @@ def merge_deployment_configs(
         if TEMPORAL_WORKER_KEY in helm_values:
             helm_values[TEMPORAL_WORKER_KEY]["env"] = agent_config.env
 
-        encoded_principal = _encode_principal_context(manifest)
-        if encoded_principal:
-            helm_values["env"][EnvVarKeys.AUTH_PRINCIPAL_B64] = encoded_principal
+    # Add auth principal env var if manifest principal is set
+    encoded_principal = _encode_principal_context(manifest)
+    if encoded_principal:
+        if "env" not in helm_values:
+            helm_values["env"] = {}
+        helm_values["env"][EnvVarKeys.AUTH_PRINCIPAL_B64.value] = encoded_principal
 
     if manifest.deployment and manifest.deployment.imagePullSecrets:
         pull_secrets = [
@@ -228,10 +246,16 @@ def merge_deployment_configs(
     # Convert the env vars to a list of dictionaries
     if "env" in helm_values:
         helm_values["env"] = convert_env_vars_dict_to_list(helm_values["env"])
+
+    # Convert the temporal worker env vars to a list of dictionaries
     if TEMPORAL_WORKER_KEY in helm_values and "env" in helm_values[TEMPORAL_WORKER_KEY]:
         helm_values[TEMPORAL_WORKER_KEY]["env"] = convert_env_vars_dict_to_list(
             helm_values[TEMPORAL_WORKER_KEY]["env"]
         )
+    
+    # Add dynamic ACP command based on manifest configuration
+    add_acp_command_to_helm_values(helm_values, manifest, manifest_path)
+    
     print("Deploying with the following helm values: ", helm_values)
     return helm_values
 
@@ -287,7 +311,7 @@ def deploy_agent(
     add_helm_repo()
 
     # Merge configurations
-    helm_values = merge_deployment_configs(manifest, override_config, deploy_overrides)
+    helm_values = merge_deployment_configs(manifest, override_config, deploy_overrides, manifest_path)
 
     # Create values file
     values_file = create_helm_values_file(helm_values)

agentex/lib/cli/handlers/run_handlers.py

@@ -11,6 +11,11 @@ from agentex.lib.cli.handlers.cleanup_handlers import (
     cleanup_agent_workflows,
     should_cleanup_on_restart
 )
+from agentex.lib.cli.utils.path_utils import (
+    get_file_paths,
+    calculate_uvicorn_target_for_local,
+)
+
 from agentex.lib.environment_variables import EnvVarKeys
 from agentex.lib.sdk.config.agent_manifest import AgentManifest
 from agentex.lib.utils.logging import make_logger
@@ -104,7 +109,10 @@ async def start_temporal_worker_with_reload(
             # PRE-RESTART CLEANUP - NEW!
             if current_process is not None:
                 # Extract agent name from worker path for cleanup
-                agent_name = worker_path.parent.parent.name
+
+                agent_name = env.get("AGENT_NAME")
+                if agent_name is None:
+                    agent_name = worker_path.parent.parent.name
                 
                 # Perform cleanup if configured
                 if should_cleanup_on_restart():
@@ -180,15 +188,17 @@ async def start_temporal_worker_with_reload(
 
 
 async def start_acp_server(
-    acp_path: Path, port: int, env: dict[str, str]
+    acp_path: Path, port: int, env: dict[str, str], manifest_dir: Path
 ) -> asyncio.subprocess.Process:
     """Start the ACP server process"""
-    # Use the actual file path instead of module path for better reload detection
+    # Use file path relative to manifest directory if possible
+    uvicorn_target = calculate_uvicorn_target_for_local(acp_path, manifest_dir)
+    
     cmd = [
         sys.executable,
         "-m",
         "uvicorn",
-        f"{acp_path.parent.name}.acp:acp",
+        f"{uvicorn_target}:acp",
         "--reload",
         "--reload-dir",
         str(acp_path.parent),  # Watch the project directory specifically
@@ -201,7 +211,7 @@ async def start_acp_server(
     console.print(f"[blue]Starting ACP server from {acp_path} on port {port}...[/blue]")
     return await asyncio.create_subprocess_exec(
         *cmd,
-        cwd=acp_path.parent.parent,
+        cwd=manifest_dir,  # Always use manifest directory as CWD for consistency
         env=env,
         stdout=asyncio.subprocess.PIPE,
         stderr=asyncio.subprocess.STDOUT,
@@ -218,7 +228,7 @@ async def start_temporal_worker(
 
     return await asyncio.create_subprocess_exec(
         *cmd,
-        cwd=worker_path.parent,
+        cwd=worker_path.parent,  # Use worker directory as CWD for imports to work
         env=env,
         stdout=asyncio.subprocess.PIPE,
         stderr=asyncio.subprocess.STDOUT,
@@ -280,8 +290,9 @@ async def run_agent(manifest_path: str):
         )
 
         # Start ACP server
+        manifest_dir = Path(manifest_path).parent
         acp_process = await start_acp_server(
-            file_paths["acp"], manifest.local_development.agent.port, agent_env
+            file_paths["acp"], manifest.local_development.agent.port, agent_env, manifest_dir
         )
         process_manager.add_process(acp_process)
 
@@ -291,7 +302,7 @@ async def run_agent(manifest_path: str):
         tasks = [acp_output_task]
 
         # Start temporal worker if needed
-        if is_temporal_agent(manifest):
+        if is_temporal_agent(manifest) and file_paths["worker"]:
             worker_task = await start_temporal_worker_with_reload(file_paths["worker"], agent_env, process_manager)
             tasks.append(worker_task)
 
@@ -323,92 +334,7 @@ async def run_agent(manifest_path: str):
         await process_manager.cleanup_processes()
 
 
-def resolve_and_validate_path(base_path: Path, configured_path: str, file_type: str) -> Path:
-    """Resolve and validate a configured path"""
-    path_obj = Path(configured_path)
-
-    if path_obj.is_absolute():
-        # Absolute path - use as-is
-        resolved_path = path_obj
-    else:
-        # Relative path - resolve relative to manifest directory
-        resolved_path = (base_path / configured_path).resolve()
-
-    # Validate the file exists
-    if not resolved_path.exists():
-        raise RunError(
-            f"{file_type} file not found: {resolved_path}\n"
-            f"  Configured path: {configured_path}\n"
-            f"  Resolved from manifest: {base_path}"
-        )
-
-    # Validate it's actually a file
-    if not resolved_path.is_file():
-        raise RunError(f"{file_type} path is not a file: {resolved_path}")
-
-    return resolved_path
-
-
-def validate_path_security(resolved_path: Path, manifest_dir: Path) -> None:
-    """Basic security validation for resolved paths"""
-    try:
-        # Ensure the resolved path is accessible
-        resolved_path.resolve()
-
-        # Optional: Add warnings for paths that go too far up
-        try:
-            # Check if path goes more than 3 levels up from manifest
-            relative_to_manifest = resolved_path.relative_to(manifest_dir.parent.parent.parent)
-            if str(relative_to_manifest).startswith(".."):
-                logger.warning(
-                    f"Path goes significantly outside project structure: {resolved_path}"
-                )
-        except ValueError:
-            # Path is outside the tree - that's okay, just log it
-            logger.info(f"Using path outside manifest directory tree: {resolved_path}")
-
-    except Exception as e:
-        raise RunError(f"Path resolution failed: {resolved_path} - {str(e)}") from e
-
 
-def get_file_paths(manifest: AgentManifest, manifest_path: str) -> dict[str, Path]:
-    """Get resolved file paths from manifest configuration"""
-    manifest_dir = Path(manifest_path).parent.resolve()
-
-    # Use configured paths or fall back to defaults for backward compatibility
-    if manifest.local_development and manifest.local_development.paths:
-        paths_config = manifest.local_development.paths
-
-        # Resolve ACP path
-        acp_path = resolve_and_validate_path(manifest_dir, paths_config.acp, "ACP server")
-        validate_path_security(acp_path, manifest_dir)
-
-        # Resolve worker path if specified
-        worker_path = None
-        if paths_config.worker:
-            worker_path = resolve_and_validate_path(
-                manifest_dir, paths_config.worker, "Temporal worker"
-            )
-            validate_path_security(worker_path, manifest_dir)
-    else:
-        # Backward compatibility: use old hardcoded structure
-        project_dir = manifest_dir / "project"
-        acp_path = project_dir / "acp.py"
-        worker_path = project_dir / "run_worker.py" if is_temporal_agent(manifest) else None
-
-        # Validate backward compatibility paths
-        if not acp_path.exists():
-            raise RunError(f"ACP file not found: {acp_path}")
-
-        if worker_path and not worker_path.exists():
-            raise RunError(f"Worker file not found: {worker_path}")
-
-    return {
-        "acp": acp_path,
-        "worker": worker_path,
-        "acp_dir": acp_path.parent,
-        "worker_dir": worker_path.parent if worker_path else None,
-    }
 
 
 def create_agent_environment(manifest: AgentManifest) -> dict[str, str]:

agentex/lib/cli/templates/sync/project/acp.py.j2

@@ -1,75 +1,26 @@
-import json
-from agentex.lib import adk
+from typing import AsyncGenerator, Union
 from agentex.lib.sdk.fastacp.fastacp import FastACP
-from agentex.lib.types.fastacp import AgenticACPConfig
-from agentex.lib.types.acp import CancelTaskParams, CreateTaskParams, SendEventParams
+from agentex.lib.types.acp import SendMessageParams
 
+from agentex.lib.types.task_message_updates import TaskMessageUpdate
+from agentex.types.task_message_content import TaskMessageContent
 from agentex.types.text_content import TextContent
 from agentex.lib.utils.logging import make_logger
 
 logger = make_logger(__name__)
 
 
-# Create an ACP server with base configuration
-# This sets up the core server that will handle task creation, events, and cancellation
+# Create an ACP server
 acp = FastACP.create(
-    acp_type="agentic",
-    config=AgenticACPConfig(
-        type="base",
-    ),
+    acp_type="sync",
 )
 
-@acp.on_task_create
-async def handle_task_create(params: CreateTaskParams):
-    # This handler is called first whenever a new task is created.
-    # It's a good place to initialize any state or resources needed for the task.
-
-    #########################################################
-    # 1. (👋) Do task initialization here.
-    #########################################################
-
-    # Acknowledge that the task has been created.
-    await adk.messages.create(
-        task_id=params.task.id,
-        content=TextContent(
-            author="agent",
-            content=f"Hello! I've received your task. Normally you can do some state initialization here, or just pass and do nothing until you get your first event. For now I'm just acknowledging that I've received a task with the following params:\n\n{json.dumps(params.params, indent=2)}.\n\nYou should only see this message once, when the task is created. All subsequent events will be handled by the `on_task_event_send` handler.",
-        ),
-    )
-
-@acp.on_task_event_send
-async def handle_event_send(params: SendEventParams):
-    # This handler is called whenever a new event (like a message) is sent to the task
-    
-    #########################################################
-    # 2. (👋) Echo back the client's message to show it in the UI.
-    #########################################################
-    
-    # This is not done by default so the agent developer has full control over what is shown to the user.
-    if params.event.content:
-        await adk.messages.create(task_id=params.task.id, content=params.event.content)
-
-    #########################################################
-    # 3. (👋) Send a simple response message.
-    #########################################################
-
-    # In future tutorials, this is where we'll add more sophisticated response logic.
-    await adk.messages.create(
-        task_id=params.task.id,
-        content=TextContent(
-            author="agent",
-            content=f"Hello! I've received your message. I can't respond right now, but in future tutorials we'll see how you can get me to intelligently respond to your message.",
-        ),
-    )
-
-@acp.on_task_cancel
-async def handle_task_cancel(params: CancelTaskParams):
-    # This handler is called when a task is cancelled.
-    # It's useful for cleaning up any resources or state associated with the task.
-
-    #########################################################
-    # 4. (👋) Do task cleanup here.
-    #########################################################
-
-    # This is mostly for durable workflows that are cancellable like Temporal, but we will leave it here for demonstration purposes.
-    logger.info(f"Hello! I've received task cancel for task {params.task.id}: {params.task}. This isn't necessary for this example, but it's good to know that it's available.")
+@acp.on_message_send
+async def handle_message_send(
+    params: SendMessageParams
+) -> TaskMessageContent | list[TaskMessageContent] | AsyncGenerator[TaskMessageUpdate, None]:
+    """Default message handler with streaming support"""
+    return TextContent(
+        author="agent",
+        content=f"Hello! I've received your message. Here's a generic response, but in future tutorials we'll see how you can get me to intelligently respond to your message. This is what I heard you say: {params.content.content}",
+    )