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

agentex/lib/adk/_modules/acp.py

@@ -205,6 +205,8 @@ class ACPModule:
         self,
         task_id: str | None = None,
         task_name: str | None = None,
+        agent_id: str | None = None,
+        agent_name: str | None = None,
         trace_id: str | None = None,
         parent_span_id: str | None = None,
         start_to_close_timeout: timedelta = timedelta(seconds=5),
@@ -212,11 +214,13 @@ class ACPModule:
         retry_policy: RetryPolicy = DEFAULT_RETRY_POLICY,
     ) -> Task:
         """
-        Cancel a task.
+        Cancel a task by sending cancel request to the agent that owns the task.
 
         Args:
-            task_id: The ID of the task to cancel.
-            task_name: The name of the task to cancel.
+            task_id: ID of the task to cancel.
+            task_name: Name of the task to cancel.
+            agent_id: ID of the agent that owns the task.
+            agent_name: Name of the agent that owns the task.
             trace_id: The trace ID for the task.
             parent_span_id: The parent span ID for the task.
             start_to_close_timeout: The start to close timeout for the task.
@@ -225,6 +229,10 @@ class ACPModule:
 
         Returns:
             The task entry.
+            
+        Raises:
+            ValueError: If neither agent_name nor agent_id is provided,
+                       or if neither task_name nor task_id is provided
         """
         if in_temporal_workflow():
             return await ActivityHelpers.execute_activity(
@@ -232,6 +240,8 @@ class ACPModule:
                 request=TaskCancelParams(
                     task_id=task_id,
                     task_name=task_name,
+                    agent_id=agent_id,
+                    agent_name=agent_name,
                     trace_id=trace_id,
                     parent_span_id=parent_span_id,
                 ),
@@ -244,6 +254,8 @@ class ACPModule:
             return await self._acp_service.task_cancel(
                 task_id=task_id,
                 task_name=task_name,
+                agent_id=agent_id,
+                agent_name=agent_name,
                 trace_id=trace_id,
                 parent_span_id=parent_span_id,
             )

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

@@ -88,6 +88,7 @@ class OpenAIModule:
         mcp_timeout_seconds: int | None = None,
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
+        max_turns: int | None = None,
     ) -> SerializableRunResult | RunResult:
         """
         Run an agent without streaming or TaskMessage creation.
@@ -114,6 +115,7 @@ class OpenAIModule:
             mcp_timeout_seconds: Optional param to set the timeout threshold for the MCP servers. Defaults to 5 seconds.
             input_guardrails: Optional list of input guardrails to run on initial user input.
             output_guardrails: Optional list of output guardrails to run on final agent output.
+            max_turns: Maximum number of turns the agent can take. Uses Runner's default if None.
 
         Returns:
             Union[SerializableRunResult, RunResult]: SerializableRunResult when in Temporal, RunResult otherwise.
@@ -136,6 +138,7 @@ class OpenAIModule:
                 mcp_timeout_seconds=mcp_timeout_seconds,
                 input_guardrails=input_guardrails,
                 output_guardrails=output_guardrails,
+                max_turns=max_turns,
             )
             return await ActivityHelpers.execute_activity(
                 activity_name=OpenAIActivityName.RUN_AGENT,
@@ -163,6 +166,7 @@ class OpenAIModule:
                 mcp_timeout_seconds=mcp_timeout_seconds,
                 input_guardrails=input_guardrails,
                 output_guardrails=output_guardrails,
+                max_turns=max_turns,
             )
 
     async def run_agent_auto_send(
@@ -191,6 +195,7 @@ class OpenAIModule:
         mcp_timeout_seconds: int | None = None,
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
+        max_turns: int | None = None,
     ) -> SerializableRunResult | RunResult:
         """
         Run an agent with automatic TaskMessage creation.
@@ -216,6 +221,7 @@ class OpenAIModule:
             mcp_timeout_seconds: Optional param to set the timeout threshold for the MCP servers. Defaults to 5 seconds.
             input_guardrails: Optional list of input guardrails to run on initial user input.
             output_guardrails: Optional list of output guardrails to run on final agent output.
+            max_turns: Maximum number of turns the agent can take. Uses Runner's default if None.
 
         Returns:
             Union[SerializableRunResult, RunResult]: SerializableRunResult when in Temporal, RunResult otherwise.
@@ -239,6 +245,7 @@ class OpenAIModule:
                 mcp_timeout_seconds=mcp_timeout_seconds,
                 input_guardrails=input_guardrails,
                 output_guardrails=output_guardrails,
+                max_turns=max_turns,
             )
             return await ActivityHelpers.execute_activity(
                 activity_name=OpenAIActivityName.RUN_AGENT_AUTO_SEND,
@@ -267,6 +274,7 @@ class OpenAIModule:
                 mcp_timeout_seconds=mcp_timeout_seconds,
                 input_guardrails=input_guardrails,
                 output_guardrails=output_guardrails,
+                max_turns=max_turns,
             )
 
     async def run_agent_streamed(
@@ -291,6 +299,7 @@ class OpenAIModule:
         mcp_timeout_seconds: int | None = None,
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
+        max_turns: int | None = None,
     ) -> RunResultStreaming:
         """
         Run an agent with streaming enabled but no TaskMessage creation.
@@ -320,6 +329,7 @@ class OpenAIModule:
             mcp_timeout_seconds: Optional param to set the timeout threshold for the MCP servers. Defaults to 5 seconds.
             input_guardrails: Optional list of input guardrails to run on initial user input.
             output_guardrails: Optional list of output guardrails to run on final agent output.
+            max_turns: Maximum number of turns the agent can take. Uses Runner's default if None.
 
         Returns:
             RunResultStreaming: The result of the agent run with streaming.
@@ -352,6 +362,7 @@ class OpenAIModule:
             mcp_timeout_seconds=mcp_timeout_seconds,
             input_guardrails=input_guardrails,
             output_guardrails=output_guardrails,
+            max_turns=max_turns,
         )
 
     async def run_agent_streamed_auto_send(
@@ -380,6 +391,7 @@ class OpenAIModule:
         mcp_timeout_seconds: int | None = None,
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
+        max_turns: int | None = None,
     ) -> SerializableRunResultStreaming | RunResultStreaming:
         """
         Run an agent with streaming enabled and automatic TaskMessage creation.
@@ -405,6 +417,7 @@ class OpenAIModule:
             output_type: Optional output type.
             tool_use_behavior: Optional tool use behavior.
             mcp_timeout_seconds: Optional param to set the timeout threshold for the MCP servers. Defaults to 5 seconds.
+            max_turns: Maximum number of turns the agent can take. Uses Runner's default if None.
 
         Returns:
             Union[SerializableRunResultStreaming, RunResultStreaming]: SerializableRunResultStreaming when in Temporal, RunResultStreaming otherwise.
@@ -428,6 +441,7 @@ class OpenAIModule:
                 mcp_timeout_seconds=mcp_timeout_seconds,
                 input_guardrails=input_guardrails,
                 output_guardrails=output_guardrails,
+                max_turns=max_turns
             )
             return await ActivityHelpers.execute_activity(
                 activity_name=OpenAIActivityName.RUN_AGENT_STREAMED_AUTO_SEND,
@@ -456,4 +470,5 @@ class OpenAIModule:
                 mcp_timeout_seconds=mcp_timeout_seconds,
                 input_guardrails=input_guardrails,
                 output_guardrails=output_guardrails,
+                max_turns=max_turns,
             )

agentex/lib/cli/handlers/deploy_handlers.py

@@ -229,9 +229,12 @@ def merge_deployment_configs(
                 all_env_vars[EnvVarKeys.AUTH_PRINCIPAL_B64.value] = encoded_principal
             else:
                 raise DeploymentError(f"Auth principal unable to be encoded for agent_env_config: {agent_env_config}")
-                
+        
+        logger.info(f"Defined agent helm overrides: {agent_env_config.helm_overrides}")
+        logger.info(f"Before-merge helm values: {helm_values}")
         if agent_env_config.helm_overrides:
             _deep_merge(helm_values, agent_env_config.helm_overrides)
+        logger.info(f"After-merge helm values: {helm_values}")
 
     # Set final environment variables
     # Environment variable precedence: manifest -> environments.yaml -> secrets (highest)

agentex/lib/cli/templates/temporal/environments.yaml.j2

@@ -52,7 +52,7 @@ environments:
         limits:
           cpu: "1000m"
           memory: "2Gi"
-      temporal:
+      temporal-worker:
         enabled: true
         replicaCount: 2
         resources:

agentex/lib/core/services/adk/acp/acp.py

@@ -180,9 +180,19 @@ class ACPService:
         self,
         task_id: str | None = None,
         task_name: str | None = None,
+        agent_id: str | None = None,
+        agent_name: str | None = None,
         trace_id: str | None = None,
         parent_span_id: str | None = None,
-    ) -> Task:
+    ) -> Task:        
+        # Require agent identification
+        if not agent_name and not agent_id:
+            raise ValueError("Either agent_name or agent_id must be provided to identify the agent that owns the task")
+            
+        # Require task identification
+        if not task_name and not task_id:
+            raise ValueError("Either task_name or task_id must be provided to identify the task to cancel")
+        
         trace = self._tracer.trace(trace_id=trace_id)
         async with trace.span(
             parent_id=parent_span_id,
@@ -190,27 +200,32 @@ class ACPService:
             input={
                 "task_id": task_id,
                 "task_name": task_name,
+                "agent_id": agent_id,
+                "agent_name": agent_name,
             },
         ) as span:
             heartbeat_if_in_workflow("task cancel")
+            
+            # Build params for the agent (task identification)
+            params = {}
+            if task_id:
+                params["task_id"] = task_id
             if task_name:
+                params["task_name"] = task_name
+            
+            # Send cancel request to the correct agent
+            if agent_name:
                 json_rpc_response = await self._agentex_client.agents.rpc_by_name(
-                    agent_name=task_name,
+                    agent_name=agent_name,
                     method="task/cancel",
-                    params={
-                        "task_name": task_name,
-                    },
+                    params=params,
                 )
-            elif task_id:
+            else:  # agent_id is provided (validated above)
                 json_rpc_response = await self._agentex_client.agents.rpc(
-                    agent_id=task_id,
+                    agent_id=agent_id,
                     method="task/cancel",
-                    params={
-                        "task_id": task_id,
-                    },
+                    params=params,
                 )
-            else:
-                raise ValueError("Either task_name or task_id must be provided")
 
             task_entry = Task.model_validate(json_rpc_response.result)
             if span:

agentex/lib/core/services/adk/providers/openai.py

@@ -1,5 +1,4 @@
 # Standard library imports
-import json
 from contextlib import AsyncExitStack, asynccontextmanager
 from typing import Any, Literal
 
@@ -11,7 +10,8 @@ from agents.mcp import MCPServerStdio
 from mcp import StdioServerParameters
 from openai.types.responses import (
     ResponseCompletedEvent,
-    ResponseFunctionToolCall,
+    ResponseFunctionWebSearch,
+    ResponseCodeInterpreterToolCall,
     ResponseOutputItemDoneEvent,
     ResponseTextDeltaEvent,
     ResponseReasoningSummaryTextDeltaEvent,
@@ -85,6 +85,86 @@ class OpenAIService:
         self.streaming_service = streaming_service
         self.tracer = tracer
 
+    def _extract_tool_call_info(
+        self, tool_call_item: Any
+    ) -> tuple[str, str, dict[str, Any]]:
+        """
+        Extract call_id, tool_name, and tool_arguments from a tool call item.
+
+        Args:
+            tool_call_item: The tool call item to process
+
+        Returns:
+            A tuple of (call_id, tool_name, tool_arguments)
+        """
+        # Generic handling for different tool call types
+        # Try 'call_id' first, then 'id', then generate placeholder
+        if hasattr(tool_call_item, 'call_id'):
+            call_id = tool_call_item.call_id
+        elif hasattr(tool_call_item, 'id'):
+            call_id = tool_call_item.id
+        else:
+            call_id = f"unknown_call_{id(tool_call_item)}"
+            logger.warning(
+                f"Warning: Tool call item {type(tool_call_item)} has "
+                f"neither 'call_id' nor 'id' attribute, using placeholder: "
+                f"{call_id}"
+            )
+
+        if isinstance(tool_call_item, ResponseFunctionWebSearch):
+            tool_name = "web_search"
+            tool_arguments = {
+                "action": tool_call_item.action.model_dump(),
+                "status": tool_call_item.status
+            }
+        elif isinstance(tool_call_item, ResponseCodeInterpreterToolCall):
+            tool_name = "code_interpreter"
+            tool_arguments = {
+                "code": tool_call_item.code,
+                "status": tool_call_item.status
+            }
+        else:
+            # Generic handling for any tool call type
+            tool_name = getattr(tool_call_item, 'name', type(tool_call_item).__name__)
+            tool_arguments = tool_call_item.model_dump()
+            
+        return call_id, tool_name, tool_arguments
+
+    def _extract_tool_response_info(
+        self, tool_call_map: dict[str, Any], tool_output_item: Any
+    ) -> tuple[str, str, str]:
+        """
+        Extract call_id, tool_name, and content from a tool output item.
+
+        Args:
+            tool_call_map: Map of call_ids to tool_call items
+            tool_output_item: The tool output item to process
+
+        Returns:
+            A tuple of (call_id, tool_name, content)
+        """
+        # Extract call_id and content from the tool_output_item
+        # Handle both dictionary access and attribute access
+        if hasattr(tool_output_item, 'get') and callable(tool_output_item.get):
+            # Dictionary-like access
+            call_id = tool_output_item["call_id"]
+            content = tool_output_item["output"]
+        else:
+            # Attribute access for structured objects
+            call_id = getattr(tool_output_item, 'call_id', None)
+            content = getattr(tool_output_item, 'output', None)
+
+        # Get the name from the tool call map using generic approach
+        tool_call = tool_call_map[call_id]
+        if hasattr(tool_call, "name"):
+            tool_name = getattr(tool_call, "name")
+        elif hasattr(tool_call, "type"):
+            tool_name = getattr(tool_call, "type")
+        else:
+            tool_name = type(tool_call).__name__
+
+        return call_id, tool_name, content
+
     async def run_agent(
         self,
         input_list: list[dict[str, Any]],
@@ -107,6 +187,7 @@ class OpenAIService:
         mcp_timeout_seconds: int | None = None,
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
+        max_turns: int | None = None,
     ) -> RunResult:
         """
         Run an agent without streaming or TaskMessage creation.
@@ -131,6 +212,8 @@ class OpenAIService:
                 initial user input.
             output_guardrails: Optional list of output guardrails to run on 
                 final agent output.
+            mcp_timeout_seconds: Optional param to set the timeout threshold for the MCP servers. Defaults to 5 seconds.
+            max_turns: Maximum number of turns the agent can take. Uses Runner's default if None.
         Returns:
             SerializableRunResult: The result of the agent run.
         """
@@ -152,6 +235,7 @@ class OpenAIService:
                 "tools": tools,
                 "output_type": output_type,
                 "tool_use_behavior": tool_use_behavior,
+                "max_turns": max_turns,
             },
         ) as span:
             heartbeat_if_in_workflow("run agent")
@@ -159,7 +243,9 @@ class OpenAIService:
             async with mcp_server_context(
                 mcp_server_params, mcp_timeout_seconds
             ) as servers:
-                tools = [tool.to_oai_function_tool() for tool in tools] if tools else []
+                tools = [
+                    tool.to_oai_function_tool()for tool in tools
+                ] if tools else []
                 handoffs = (
                     [Agent(**handoff.model_dump()) for handoff in handoffs]
                     if handoffs
@@ -189,7 +275,10 @@ class OpenAIService:
                 agent = Agent(**agent_kwargs)
 
                 # Run without streaming
-                result = await Runner.run(starting_agent=agent, input=input_list)
+                if max_turns is not None:
+                    result = await Runner.run(starting_agent=agent, input=input_list, max_turns=max_turns)
+                else:
+                    result = await Runner.run(starting_agent=agent, input=input_list)
 
                 if span:
                     span.output = {
@@ -227,6 +316,7 @@ class OpenAIService:
         mcp_timeout_seconds: int | None = None,
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
+        max_turns: int | None = None,
     ) -> RunResult:
         """
         Run an agent with automatic TaskMessage creation.
@@ -249,6 +339,7 @@ class OpenAIService:
             mcp_timeout_seconds: Optional param to set the timeout threshold for the MCP servers. Defaults to 5 seconds.
             input_guardrails: Optional list of input guardrails to run on initial user input.
             output_guardrails: Optional list of output guardrails to run on final agent output.
+            max_turns: Maximum number of turns the agent can take. Uses Runner's default if None.
         Returns:
             SerializableRunResult: The result of the agent run.
         """
@@ -276,6 +367,7 @@ class OpenAIService:
                 "tools": tools,
                 "output_type": output_type,
                 "tool_use_behavior": tool_use_behavior,
+                "max_turns": max_turns,
             },
         ) as span:
             heartbeat_if_in_workflow("run agent auto send")
@@ -312,7 +404,10 @@ class OpenAIService:
                 agent = Agent(**agent_kwargs)
 
                 # Run without streaming
-                result = await Runner.run(starting_agent=agent, input=input_list)
+                if max_turns is not None:
+                    result = await Runner.run(starting_agent=agent, input=input_list, max_turns=max_turns)
+                else:
+                    result = await Runner.run(starting_agent=agent, input=input_list)
 
                 if span:
                     span.output = {
@@ -325,7 +420,7 @@ class OpenAIService:
                         "final_output": result.final_output,
                     }
 
-                tool_call_map: dict[str, ResponseFunctionToolCall] = {}
+                tool_call_map: dict[str, Any] = {}
 
                 for item in result.new_items:
                     if item.type == "message_output_item":
@@ -349,13 +444,17 @@ class OpenAIService:
                             )
 
                     elif item.type == "tool_call_item":
-                        tool_call_map[item.raw_item.call_id] = item.raw_item
+                        tool_call_item = item.raw_item
+                        
+                        # Extract tool call information using the helper method
+                        call_id, tool_name, tool_arguments = self._extract_tool_call_info(tool_call_item)
+                        tool_call_map[call_id] = tool_call_item
 
                         tool_request_content = ToolRequestContent(
                             author="agent",
-                            tool_call_id=item.raw_item.call_id,
-                            name=item.raw_item.name,
-                            arguments=json.loads(item.raw_item.arguments),
+                            tool_call_id=call_id,
+                            name=tool_name,
+                            arguments=tool_arguments,
                         )
 
                         # Create tool request using streaming context
@@ -376,11 +475,16 @@ class OpenAIService:
                     elif item.type == "tool_call_output_item":
                         tool_output_item = item.raw_item
 
+                        # Extract tool response information using the helper method
+                        call_id, tool_name, content = self._extract_tool_response_info(
+                            tool_call_map, tool_output_item
+                        )
+
                         tool_response_content = ToolResponseContent(
                             author="agent",
-                            tool_call_id=tool_output_item["call_id"],
-                            name=tool_call_map[tool_output_item["call_id"]].name,
-                            content=tool_output_item["output"],
+                            tool_call_id=call_id,
+                            name=tool_name,
+                            content=content,
                         )
                         # Create tool response using streaming context
                         async with (
@@ -422,6 +526,7 @@ class OpenAIService:
         mcp_timeout_seconds: int | None = None,
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
+        max_turns: int | None = None,
     ) -> RunResultStreaming:
         """
         Run an agent with streaming enabled but no TaskMessage creation.
@@ -446,6 +551,8 @@ class OpenAIService:
                 initial user input.
             output_guardrails: Optional list of output guardrails to run on 
                 final agent output.
+            mcp_timeout_seconds: Optional param to set the timeout threshold for the MCP servers. Defaults to 5 seconds.
+            max_turns: Maximum number of turns the agent can take. Uses Runner's default if None.
         Returns:
             RunResultStreaming: The result of the agent run with streaming.
         """
@@ -467,6 +574,7 @@ class OpenAIService:
                 "tools": tools,
                 "output_type": output_type,
                 "tool_use_behavior": tool_use_behavior,
+                "max_turns": max_turns,
             },
         ) as span:
             heartbeat_if_in_workflow("run agent streamed")
@@ -503,7 +611,10 @@ class OpenAIService:
                 agent = Agent(**agent_kwargs)
 
                 # Run with streaming (but no TaskMessage creation)
-                result = Runner.run_streamed(starting_agent=agent, input=input_list)
+                if max_turns is not None:
+                    result = Runner.run_streamed(starting_agent=agent, input=input_list, max_turns=max_turns)
+                else:
+                    result = Runner.run_streamed(starting_agent=agent, input=input_list)
 
                 if span:
                     span.output = {
@@ -541,6 +652,7 @@ class OpenAIService:
         mcp_timeout_seconds: int | None = None,
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
+        max_turns: int | None = None,
     ) -> RunResultStreaming:
         """
         Run an agent with streaming enabled and automatic TaskMessage creation.
@@ -566,6 +678,8 @@ class OpenAIService:
                 initial user input.
             output_guardrails: Optional list of output guardrails to run on 
                 final agent output.
+            mcp_timeout_seconds: Optional param to set the timeout threshold for the MCP servers. Defaults to 5 seconds.
+            max_turns: Maximum number of turns the agent can take. Uses Runner's default if None.
 
         Returns:
             RunResultStreaming: The result of the agent run with streaming.
@@ -575,7 +689,7 @@ class OpenAIService:
         if self.agentex_client is None:
             raise ValueError("Agentex client must be provided for auto_send methods")
 
-        tool_call_map: dict[str, ResponseFunctionToolCall] = {}
+        tool_call_map: dict[str, Any] = {}
 
         trace = self.tracer.trace(trace_id)
         redacted_params = redact_mcp_server_params(mcp_server_params)
@@ -596,6 +710,7 @@ class OpenAIService:
                 "tools": tools,
                 "output_type": output_type,
                 "tool_use_behavior": tool_use_behavior,
+                "max_turns": max_turns,
             },
         ) as span:
             heartbeat_if_in_workflow("run agent streamed auto send")
@@ -632,7 +747,10 @@ class OpenAIService:
                 agent = Agent(**agent_kwargs)
 
                 # Run with streaming
-                result = Runner.run_streamed(starting_agent=agent, input=input_list)
+                if max_turns is not None:
+                    result = Runner.run_streamed(starting_agent=agent, input=input_list, max_turns=max_turns)
+                else:
+                    result = Runner.run_streamed(starting_agent=agent, input=input_list)
 
                 item_id_to_streaming_context: dict[
                     str, StreamingTaskMessageContext
@@ -649,13 +767,16 @@ class OpenAIService:
                         if event.type == "run_item_stream_event":
                             if event.item.type == "tool_call_item":
                                 tool_call_item = event.item.raw_item
-                                tool_call_map[tool_call_item.call_id] = tool_call_item
+                                
+                                # Extract tool call information using the helper method
+                                call_id, tool_name, tool_arguments = self._extract_tool_call_info(tool_call_item)
+                                tool_call_map[call_id] = tool_call_item
 
                                 tool_request_content = ToolRequestContent(
                                     author="agent",
-                                    tool_call_id=tool_call_item.call_id,
-                                    name=tool_call_item.name,
-                                    arguments=json.loads(tool_call_item.arguments),
+                                    tool_call_id=call_id,
+                                    name=tool_name,
+                                    arguments=tool_arguments,
                                 )
 
                                 # Create tool request using streaming context (immediate completion)
@@ -677,13 +798,16 @@ class OpenAIService:
                             elif event.item.type == "tool_call_output_item":
                                 tool_output_item = event.item.raw_item
 
+                                # Extract tool response information using the helper method
+                                call_id, tool_name, content = self._extract_tool_response_info(
+                                    tool_call_map, tool_output_item
+                                )
+
                                 tool_response_content = ToolResponseContent(
                                     author="agent",
-                                    tool_call_id=tool_output_item["call_id"],
-                                    name=tool_call_map[
-                                        tool_output_item["call_id"]
-                                    ].name,
-                                    content=tool_output_item["output"],
+                                    tool_call_id=call_id,
+                                    name=tool_name,
+                                    content=content,
                                 )
 
                                 # Create tool response using streaming context (immediate completion)

agentex/lib/core/temporal/activities/adk/acp/acp_activities.py

@@ -45,6 +45,8 @@ class EventSendParams(BaseModelWithTraceParams):
 class TaskCancelParams(BaseModelWithTraceParams):
     task_id: str | None = None
     task_name: str | None = None
+    agent_id: str | None = None
+    agent_name: str | None = None
 
 
 class ACPActivities:
@@ -83,4 +85,8 @@ class ACPActivities:
         return await self._acp_service.task_cancel(
             task_id=params.task_id,
             task_name=params.task_name,
+            agent_id=params.agent_id,
+            agent_name=params.agent_name,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
         )