agentex-sdk 0.2.0__py3-none-any.whl → 0.2.1__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.0"  # x-release-please-version
+__version__ = "0.2.1"  # x-release-please-version

agentex/lib/adk/_modules/messages.py

@@ -3,7 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.core.adapters.streams.adapter_redis import RedisEventStreamRepository
+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
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
@@ -38,7 +38,7 @@ class MessagesModule:
     ):
         if messages_service is None:
             agentex_client = AsyncAgentex()
-            stream_repository = RedisEventStreamRepository()
+            stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,
                 stream_repository=stream_repository,

agentex/lib/adk/_modules/streaming.py

@@ -1,7 +1,7 @@
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.core.adapters.streams.adapter_redis import RedisEventStreamRepository
+from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.streaming import (
     StreamingService,
     StreamingTaskMessageContext,
@@ -33,7 +33,7 @@ class StreamingModule:
                 a new service will be created with default parameters.
         """
         if streaming_service is None:
-            stream_repository = RedisEventStreamRepository()
+            stream_repository = RedisStreamRepository()
             agentex_client = AsyncAgentex()
             self._streaming_service = StreamingService(
                 agentex_client=agentex_client,

agentex/lib/adk/providers/_modules/litellm.py

@@ -5,7 +5,7 @@ from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
 from agentex.lib.core.adapters.llm.adapter_litellm import LiteLLMGateway
-from agentex.lib.core.adapters.streams.adapter_redis import RedisEventStreamRepository
+from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.providers.litellm import LiteLLMService
 from agentex.lib.core.services.adk.streaming import StreamingService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
@@ -40,7 +40,7 @@ class LiteLLMModule:
         if litellm_service is None:
             # Create default service
             agentex_client = AsyncAgentex()
-            stream_repository = RedisEventStreamRepository()
+            stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,
                 stream_repository=stream_repository,

agentex/lib/adk/providers/_modules/openai.py

@@ -10,7 +10,7 @@ from mcp import StdioServerParameters
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.core.adapters.streams.adapter_redis import RedisEventStreamRepository
+from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.providers.openai import OpenAIService
 from agentex.lib.core.services.adk.streaming import StreamingService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
@@ -47,7 +47,7 @@ class OpenAIModule:
         if openai_service is None:
             # Create default service
             agentex_client = AsyncAgentex()
-            stream_repository = RedisEventStreamRepository()
+            stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,
                 stream_repository=stream_repository,

agentex/lib/cli/commands/init.py

@@ -1,5 +1,6 @@
 from enum import Enum
 from pathlib import Path
+from typing import Any, Dict
 
 import questionary
 from jinja2 import Environment, FileSystemLoader
@@ -23,7 +24,7 @@ class TemplateType(str, Enum):
 
 
 def render_template(
-    template_path: str, context: dict, template_type: TemplateType
+    template_path: str, context: Dict[str, Any], template_type: TemplateType
 ) -> str:
     """Render a template with the given context"""
     env = Environment(loader=FileSystemLoader(TEMPLATES_DIR / template_type.value))
@@ -32,7 +33,7 @@ def render_template(
 
 
 def create_project_structure(
-    path: Path, context: dict, template_type: TemplateType, use_uv: bool
+    path: Path, context: Dict[str, Any], template_type: TemplateType, use_uv: bool
 ):
     """Create the project structure from templates"""
     # Create project directory
@@ -74,6 +75,9 @@ def create_project_structure(
         root_templates["requirements.txt.j2"] = "requirements.txt"
         root_templates["Dockerfile.j2"] = "Dockerfile"
 
+    # Add development notebook for agents
+    root_templates["dev.ipynb.j2"] = "dev.ipynb"
+
     for template, output in root_templates.items():
         output_path = project_dir / output
         output_path.write_text(render_template(template, context, template_type))
@@ -81,7 +85,7 @@ def create_project_structure(
     console.print(f"\n[green]✓[/green] Created project structure at: {project_dir}")
 
 
-def get_project_context(answers: dict, project_path: Path, manifest_root: Path) -> dict:
+def get_project_context(answers: Dict[str, Any], project_path: Path, manifest_root: Path) -> Dict[str, Any]:
     """Get the project context from user answers"""
     # Use agent_directory_name as project_name
     project_name = answers["agent_directory_name"].replace("-", "_")
@@ -112,7 +116,7 @@ def init():
     )
 
     # Use a Rich table for template descriptions
-    table = Table(show_header=True, header_style="bold magenta")
+    table = Table(show_header=True, header_style="bold blue")
     table.add_column("Template", style="cyan", no_wrap=True)
     table.add_column("Description", style="white")
     table.add_row(

agentex/lib/cli/templates/default/README.md.j2

@@ -62,6 +62,7 @@ This file is essential for both local development and deployment of your agent.
 │   └── acp.py               # ACP server and event handlers
 ├── Dockerfile               # Container definition
 ├── manifest.yaml            # Deployment config
+├── dev.ipynb                # Development notebook for testing
 {% if use_uv %}
 └── pyproject.toml          # Dependencies (uv)
 {% else %}
@@ -76,7 +77,27 @@ This file is essential for both local development and deployment of your agent.
 - Add your own tools and capabilities
 - Implement custom state management
 
-### 2. Manage Dependencies
+### 2. Test Your Agent with the Development Notebook
+Use the included `dev.ipynb` Jupyter notebook to test your agent interactively:
+
+```bash
+# Start Jupyter notebook (make sure you have jupyter installed)
+jupyter notebook dev.ipynb
+
+# Or use VS Code to open the notebook directly
+code dev.ipynb
+```
+
+The notebook includes:
+- **Setup**: Connect to your local AgentEx backend
+- **Task creation**: Create a new task for the conversation
+- **Event sending**: Send events to the agent and get responses
+- **Async message subscription**: Subscribe to server-side events to receive agent responses
+- **Rich message display**: Beautiful formatting with timestamps and author information
+
+The notebook automatically uses your agent name (`{{ agent_name }}`) and demonstrates the agentic ACP workflow: create task → send event → subscribe to responses.
+
+### 3. Manage Dependencies
 
 {% if use_uv %}
 You chose **uv** for package management. Here's how to work with dependencies:
@@ -115,7 +136,7 @@ pip install -r requirements.txt
 - Wide compatibility
 {% endif %}
 
-### 3. Configure Credentials
+### 4. Configure Credentials
 Options:
 1. Add any required credentials to your manifest.yaml via the `env` section
 2. Export them in your shell: `export OPENAI_API_KEY=...`

agentex/lib/cli/templates/default/dev.ipynb.j2

@@ -0,0 +1,127 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36834357",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from agentex import Agentex\n",
+    "\n",
+    "client = Agentex(base_url=\"http://localhost:5003\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1c309d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "AGENT_NAME = \"{{ agent_name }}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f6e6ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# (REQUIRED) Create a new task. For Agentic agents, you must create a task for messages to be associated with.\n",
+    "\n",
+    "from typing import cast\n",
+    "import uuid\n",
+    "\n",
+    "from agentex.types import Task\n",
+    "\n",
+    "TASK_ID = str(uuid.uuid4())[:8]\n",
+    "\n",
+    "rpc_response = client.agents.rpc_by_name(\n",
+    "    agent_name=AGENT_NAME,\n",
+    "    method=\"task/create\",\n",
+    "    params={\n",
+    "        \"name\": f\"{TASK_ID}-task\",\n",
+    "        \"params\": {}\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "task = cast(Task, rpc_response.result)\n",
+    "print(task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b03b0d37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test non streaming response\n",
+    "from typing import cast\n",
+    "from agentex.types import Event\n",
+    "\n",
+    "# The response is expected to be a list of TaskMessage objects, which is a union of the following types:\n",
+    "# - TextContent: A message with just text content   \n",
+    "# - DataContent: A message with JSON-serializable data content\n",
+    "# - ToolRequestContent: A message with a tool request, which contains a JSON-serializable request to call a tool\n",
+    "# - ToolResponseContent: A message with a tool response, which contains response object from a tool call in its content\n",
+    "\n",
+    "# When processing the message/send response, if you are expecting more than TextContent, such as DataContent, ToolRequestContent, or ToolResponseContent, you can process them as well\n",
+    "\n",
+    "rpc_response = client.agents.rpc_by_name(\n",
+    "    agent_name=AGENT_NAME,\n",
+    "    method=\"event/send\",\n",
+    "    params={\n",
+    "        \"content\": {\"type\": \"text\", \"author\": \"user\", \"content\": \"Hello what can you do?\"},\n",
+    "        \"task_id\": task.id,\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "event = cast(Event, rpc_response.result)\n",
+    "print(event)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a6927cc0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from agentex.lib.utils.dev_tools import subscribe_to_async_task_messages\n",
+    "\n",
+    "task_messages = subscribe_to_async_task_messages(\n",
+    "    client=client,\n",
+    "    task=task, \n",
+    "    only_after_timestamp=event.created_at, \n",
+    "    print_messages=True,\n",
+    "    rich_print=True,\n",
+    "    timeout=5,\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

agentex/lib/cli/templates/sync/README.md.j2

@@ -60,6 +60,7 @@ This file is essential for both local development and deployment of your agent.
 │   └── acp.py               # ACP server and event handlers
 ├── Dockerfile               # Container definition
 ├── manifest.yaml            # Deployment config
+├── dev.ipynb                # Development notebook for testing
 {% if use_uv %}
 └── pyproject.toml          # Dependencies (uv)
 {% else %}
@@ -74,7 +75,26 @@ This file is essential for both local development and deployment of your agent.
 - Add your own tools and capabilities
 - Implement custom response generation
 
-### 2. Manage Dependencies
+### 2. Test Your Agent with the Development Notebook
+Use the included `dev.ipynb` Jupyter notebook to test your agent interactively:
+
+```bash
+# Start Jupyter notebook (make sure you have jupyter installed)
+jupyter notebook dev.ipynb
+
+# Or use VS Code to open the notebook directly
+code dev.ipynb
+```
+
+The notebook includes:
+- **Setup**: Connect to your local AgentEx backend
+- **Non-streaming tests**: Send messages and get complete responses
+- **Streaming tests**: Test real-time streaming responses
+- **Task management**: Optional task creation and management
+
+The notebook automatically uses your agent name (`{{ agent_name }}`) and provides examples for both streaming and non-streaming message handling.
+
+### 3. Manage Dependencies
 
 {% if use_uv %}
 You chose **uv** for package management. Here's how to work with dependencies:
@@ -113,7 +133,7 @@ pip install -r requirements.txt
 - Wide compatibility
 {% endif %}
 
-### 3. Configure Credentials
+### 4. Configure Credentials
 Options:
 1. Add any required credentials to your manifest.yaml via the `env` section
 2. Export them in your shell: `export OPENAI_API_KEY=...`

agentex/lib/cli/templates/sync/dev.ipynb.j2

@@ -0,0 +1,181 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36834357",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from agentex import Agentex\n",
+    "\n",
+    "client = Agentex(base_url=\"http://localhost:5003\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1c309d6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "AGENT_NAME = \"{{ agent_name }}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f6e6ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # (Optional) Create a new task. If you don't create a new task, each message will be sent to a new task. The server will create the task for you.\n",
+    "\n",
+    "# import uuid\n",
+    "\n",
+    "# TASK_ID = str(uuid.uuid4())[:8]\n",
+    "\n",
+    "# rpc_response = client.agents.rpc_by_name(\n",
+    "#     agent_name=AGENT_NAME,\n",
+    "#     method=\"task/create\",\n",
+    "#     params={\n",
+    "#         \"name\": f\"{TASK_ID}-task\",\n",
+    "#         \"params\": {}\n",
+    "#     }\n",
+    "# )\n",
+    "\n",
+    "# task = rpc_response.result\n",
+    "# print(task)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b03b0d37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test non streaming response\n",
+    "from typing import List, cast\n",
+    "from agentex.types import TaskMessage, TextContent\n",
+    "\n",
+    "# The response is expected to be a list of TaskMessage objects, which is a union of the following types:\n",
+    "# - TextContent: A message with just text content   \n",
+    "# - DataContent: A message with JSON-serializable data content\n",
+    "# - ToolRequestContent: A message with a tool request, which contains a JSON-serializable request to call a tool\n",
+    "# - ToolResponseContent: A message with a tool response, which contains response object from a tool call in its content\n",
+    "\n",
+    "# When processing the message/send response, if you are expecting more than TextContent, such as DataContent, ToolRequestContent, or ToolResponseContent, you can process them as well\n",
+    "\n",
+    "rpc_response = client.agents.rpc_by_name(\n",
+    "    agent_name=AGENT_NAME,\n",
+    "    method=\"message/send\",\n",
+    "    params={\n",
+    "        \"content\": {\"type\": \"text\", \"author\": \"user\", \"content\": \"Hello what can you do?\"},\n",
+    "        \"stream\": False\n",
+    "    }\n",
+    ")\n",
+    "\n",
+    "# # Extract and print just the text content from the response\n",
+    "# # The response is expected to be a dict with a \"result\" key containing a list of message dicts\n",
+    "if rpc_response and rpc_response.result:\n",
+    "\n",
+    "    # We know that the result of the message/send when stream is set to False will be a list of TaskMessage objects\n",
+    "    task_message_list = cast(List[TaskMessage], rpc_response.result)\n",
+    "    for task_message in rpc_response.result:\n",
+    "        if isinstance(task_message, TaskMessage):\n",
+    "            content = task_message.content\n",
+    "            if isinstance(content, TextContent):\n",
+    "                text = content.content\n",
+    "                print(text)\n",
+    "        else:\n",
+    "            print(f\"Found non-text {type(task_message)} object in response.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79688331",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Test streaming response\n",
+    "import json\n",
+    "from agentex.types import AgentRpcResponse\n",
+    "from agentex.types.agent_rpc_result import StreamTaskMessageDelta, StreamTaskMessageFull\n",
+    "from agentex.types.text_delta import TextDelta\n",
+    "from agentex.types.task_message_update import TaskMessageUpdate\n",
+    "\n",
+    "\n",
+    "# The result object of message/send will be a TaskMessageUpdate which is a union of the following types:\n",
+    "# - StreamTaskMessageStart: \n",
+    "#   - An indicator that a streaming message was started, doesn't contain any useful content\n",
+    "# - StreamTaskMessageDelta: \n",
+    "#   - A delta of a streaming message, contains the text delta to aggregate\n",
+    "# - StreamTaskMessageDone: \n",
+    "#   - An indicator that a streaming message was done, doesn't contain any useful content\n",
+    "# - StreamTaskMessageFull: \n",
+    "#   - A non-streaming message, there is nothing to aggregate, since this contains the full message, not deltas\n",
+    "\n",
+    "# Whenn processing StreamTaskMessageDelta, if you are expecting more than TextDeltas, such as DataDelta, ToolRequestDelta, or ToolResponseDelta, you can process them as well\n",
+    "# Whenn processing StreamTaskMessageFull, if you are expecting more than TextContent, such as DataContent, ToolRequestContent, or ToolResponseContent, you can process them as well\n",
+    "\n",
+    "with client.agents.with_streaming_response.rpc_by_name(\n",
+    "    agent_name=AGENT_NAME,\n",
+    "    method=\"message/send\",\n",
+    "    params={\n",
+    "        \"content\": {\"type\": \"text\", \"author\": \"user\", \"content\": \"Hello what can you do?\"},\n",
+    "        \"stream\": True\n",
+    "    }\n",
+    ") as response:\n",
+    "    for agent_rpc_response_str in response.iter_text():\n",
+    "        chunk_rpc_response = AgentRpcResponse.model_validate(json.loads(agent_rpc_response_str))\n",
+    "        # We know that the result of the message/send when stream is set to True will be a TaskMessageUpdate\n",
+    "        task_message_update = cast(TaskMessageUpdate, chunk_rpc_response.result)\n",
+    "\n",
+    "        # Print oly the text deltas as they arrive or any full messages\n",
+    "        if isinstance(task_message_update, StreamTaskMessageDelta):\n",
+    "            delta = task_message_update.delta\n",
+    "            if isinstance(delta, TextDelta):\n",
+    "                print(delta.text_delta, end=\"\", flush=True)\n",
+    "            else:\n",
+    "                print(f\"Found non-text {type(task_message)} object in streaming message.\")\n",
+    "        elif isinstance(task_message_update, StreamTaskMessageFull):\n",
+    "            content = task_message_update.content\n",
+    "            if isinstance(content, TextContent):\n",
+    "                print(content.content)\n",
+    "            else:\n",
+    "                print(f\"Found non-text {type(task_message)} object in full message.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ffb663c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

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

@@ -1,26 +1,75 @@
-from typing import AsyncGenerator, Union
+import json
+from agentex.lib import adk
 from agentex.lib.sdk.fastacp.fastacp import FastACP
-from agentex.lib.types.acp import SendMessageParams
+from agentex.lib.types.fastacp import AgenticACPConfig
+from agentex.lib.types.acp import CancelTaskParams, CreateTaskParams, SendEventParams
 
-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
+# Create an ACP server with base configuration
+# This sets up the core server that will handle task creation, events, and cancellation
 acp = FastACP.create(
-    acp_type="sync",
+    acp_type="agentic",
+    config=AgenticACPConfig(
+        type="base",
+    ),
 )
 
-@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}",
+@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.")

agentex/lib/cli/templates/temporal/README.md.j2

@@ -68,6 +68,7 @@ This file is essential for both local development and deployment of your agent.
 │   └── run_worker.py        # Temporal worker setup
 ├── Dockerfile               # Container definition
 ├── manifest.yaml            # Deployment config
+├── dev.ipynb                # Development notebook for testing
 {% if use_uv %}
 └── pyproject.toml          # Dependencies (uv)
 {% else %}
@@ -82,12 +83,32 @@ This file is essential for both local development and deployment of your agent.
 - Add your own tools and capabilities
 - Implement custom state management
 
-### 2. Develop Temporal Workflows
+### 2. Test Your Agent with the Development Notebook
+Use the included `dev.ipynb` Jupyter notebook to test your agent interactively:
+
+```bash
+# Start Jupyter notebook (make sure you have jupyter installed)
+jupyter notebook dev.ipynb
+
+# Or use VS Code to open the notebook directly
+code dev.ipynb
+```
+
+The notebook includes:
+- **Setup**: Connect to your local AgentEx backend
+- **Task creation**: Create a new task for the conversation
+- **Event sending**: Send events to the agent and get responses
+- **Async message subscription**: Subscribe to server-side events to receive agent responses
+- **Rich message display**: Beautiful formatting with timestamps and author information
+
+The notebook automatically uses your agent name (`{{ agent_name }}`) and demonstrates the agentic ACP workflow: create task → send event → subscribe to responses.
+
+### 3. Develop Temporal Workflows
 - Edit `workflow.py` to define your agent's async workflow logic
 - Modify `activities.py` to add custom activities
 - Use `run_worker.py` to configure the Temporal worker
 
-### 3. Manage Dependencies
+### 4. Manage Dependencies
 
 {% if use_uv %}
 You chose **uv** for package management. Here's how to work with dependencies:
@@ -135,7 +156,7 @@ pip install -r requirements.txt
 - Wide compatibility
 {% endif %}
 
-### 4. Configure Credentials
+### 5. Configure Credentials
 - Add any required credentials to your manifest.yaml
 - For local development, create a `.env` file in the project directory
 - Use `load_dotenv()` only in development mode: