agentex-sdk 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

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}",
+    )

agentex/lib/cli/utils/path_utils.py

@@ -0,0 +1,143 @@
+from pathlib import Path
+from typing import Dict
+
+from agentex.lib.sdk.config.agent_manifest import AgentManifest
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+
+
+class PathResolutionError(Exception):
+    """An error occurred during path resolution"""
+
+
+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 - resolve to canonical form
+        resolved_path = path_obj.resolve()
+    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 PathResolutionError(
+            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 PathResolutionError(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 PathResolutionError(f"Path resolution failed: {resolved_path} - {str(e)}") from e
+
+
+def get_file_paths(manifest: AgentManifest, manifest_path: str) -> Dict[str, Path | None]:
+    """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").resolve()
+        worker_path = (project_dir / "run_worker.py").resolve() if manifest.agent.is_temporal_agent() else None
+
+        # Validate backward compatibility paths
+        if not acp_path.exists():
+            raise PathResolutionError(f"ACP file not found: {acp_path}")
+
+        if worker_path and not worker_path.exists():
+            raise PathResolutionError(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 calculate_uvicorn_target_for_local(acp_path: Path, manifest_dir: Path) -> str:
+    """Calculate the uvicorn target path for local development"""
+    # Ensure both paths are resolved to canonical form for accurate comparison
+    acp_resolved = acp_path.resolve()
+    manifest_resolved = manifest_dir.resolve()
+    
+    try:
+        # Try to use path relative to manifest directory
+        acp_relative = acp_resolved.relative_to(manifest_resolved)
+        # Convert to module notation: project/acp.py -> project.acp
+        module_path = str(acp_relative.with_suffix(''))  # Remove .py extension
+        module_path = module_path.replace('/', '.')  # Convert slashes to dots
+        module_path = module_path.replace('\\', '.')  # Handle Windows paths
+        return module_path
+    except ValueError:
+        # Path cannot be made relative - use absolute file path
+        logger.warning(f"ACP file {acp_resolved} cannot be made relative to manifest directory {manifest_resolved}, using absolute file path")
+        return str(acp_resolved)
+
+
+def calculate_docker_acp_module(manifest: AgentManifest, manifest_path: str) -> str:
+    """Calculate the Python module path for the ACP file in the Docker container
+    
+    This should return the same module notation as local development for consistency.
+    """
+    # Use the same logic as local development
+    manifest_dir = Path(manifest_path).parent
+    
+    # Get the configured ACP path (could be relative or absolute)
+    if manifest.local_development and manifest.local_development.paths:
+        acp_config_path = manifest.local_development.paths.acp
+    else:
+        acp_config_path = "project/acp.py"  # Default
+    
+    # Resolve to actual file path
+    acp_path = resolve_and_validate_path(manifest_dir, acp_config_path, "ACP")
+    
+    # Use the same module calculation as local development
+    return calculate_uvicorn_target_for_local(acp_path, manifest_dir)
+
+
+ 

agentex/lib/core/temporal/activities/__init__.py

@@ -1,3 +1,4 @@
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from scale_gp import SGPClient, SGPClientError
 
 from agentex import AsyncAgentex
@@ -58,7 +59,7 @@ def get_all_activities(sgp_client=None):
 
     llm_gateway = LiteLLMGateway()
     stream_repository = RedisStreamRepository()
-    agentex_client = AsyncAgentex()
+    agentex_client = create_async_agentex_client()
     tracer = AsyncTracer(agentex_client)
 
     # Services

agentex/lib/core/tracing/processors/agentex_tracing_processor.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, override
 
 from agentex import Agentex, AsyncAgentex
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.tracing.processors.tracing_processor_interface import (
     AsyncTracingProcessor,
     SyncTracingProcessor,
@@ -65,7 +66,7 @@ class AgentexSyncTracingProcessor(SyncTracingProcessor):
 
 class AgentexAsyncTracingProcessor(AsyncTracingProcessor):
     def __init__(self, config: AgentexTracingProcessorConfig):
-        self.client = AsyncAgentex()
+        self.client = create_async_agentex_client()
 
     @override
     async def on_span_start(self, span: Span) -> None:

agentex/lib/environment_variables.py

@@ -4,12 +4,15 @@ import os
 from enum import Enum
 from pathlib import Path
 
+from agentex.lib.utils.logging import make_logger
 from dotenv import load_dotenv
 
 from agentex.lib.utils.model_utils import BaseModel
 
 PROJECT_ROOT = Path(__file__).resolve().parents[2]
 
+logger = make_logger(__name__)
+
 
 class EnvVarKeys(str, Enum):
     ENVIRONMENT = "ENVIRONMENT"
@@ -37,7 +40,7 @@ class Environment(str, Enum):
     PROD = "production"
 
 
-refreshed_environment_variables = None
+refreshed_environment_variables: "EnvironmentVariables" | None = None
 
 
 class EnvironmentVariables(BaseModel):
@@ -64,6 +67,7 @@ class EnvironmentVariables(BaseModel):
         if refreshed_environment_variables is not None:
             return refreshed_environment_variables
 
+        logger.info("Refreshing environment variables")
         if os.environ.get(EnvVarKeys.ENVIRONMENT) == Environment.DEV:
             # Load global .env file first
             global_env_path = PROJECT_ROOT / ".env"

agentex/lib/sdk/fastacp/base/base_acp_server.py

@@ -9,7 +9,7 @@ from typing import Any
 
 import httpx
 import uvicorn
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from fastapi import FastAPI, Request
 from fastapi.responses import StreamingResponse
 from pydantic import TypeAdapter, ValidationError
@@ -397,9 +397,10 @@ class BaseACPServer(FastAPI):
 
                         os.environ["AGENT_ID"] = agent_id
                         os.environ["AGENT_NAME"] = agent_name
-                        refreshed_environment_variables.AGENT_ID = agent_id
-                        refreshed_environment_variables.AGENT_NAME = agent_name
-                        get_async_agentex_client()  # refresh cache
+                        env_vars.AGENT_ID = agent_id
+                        env_vars.AGENT_NAME = agent_name
+                        global refreshed_environment_variables
+                        refreshed_environment_variables = env_vars
                         logger.info(
                             f"Successfully registered agent '{env_vars.AGENT_NAME}' with Agentex server with acp_url: {full_acp_url}. Registration data: {registration_data}"
                         )

agentex/lib/sdk/fastacp/impl/agentic_base_acp.py

@@ -1,4 +1,6 @@
 from typing import Any
+
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from typing_extensions import override
 from agentex import AsyncAgentex
 from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
@@ -24,7 +26,7 @@ class AgenticBaseACP(BaseACPServer):
     def __init__(self):
         super().__init__()
         self._setup_handlers()
-        self._agentex_client = AsyncAgentex()
+        self._agentex_client = create_async_agentex_client()
 
     @classmethod
     @override

agentex/lib/types/converters.py

@@ -0,0 +1,60 @@
+from agentex.types.task_message import TaskMessage
+from agentex.types.text_content import TextContent
+from agentex.types.tool_request_content import ToolRequestContent
+from agentex.types.tool_response_content import ToolResponseContent
+import json
+from agents import TResponseInputItem
+
+
+def convert_task_messages_to_oai_agents_inputs(
+    task_messages: list[TaskMessage],
+) -> list[TResponseInputItem]:
+    """
+    Convert a list of TaskMessages to a list of OpenAI Agents SDK inputs (TResponseInputItem).
+
+    Args:
+        task_messages: The list of TaskMessages to convert.
+
+    Returns:
+        A list of OpenAI Agents SDK inputs (TResponseInputItem).
+    """
+    converted_messages = []
+    for task_message in task_messages:
+        task_message_content = task_message.content
+        if isinstance(task_message_content, TextContent):
+            converted_messages.append(
+                {
+                    "role": (
+                        "user" if task_message_content.author == "user" else "assistant"
+                    ),
+                    "content": task_message_content.content,
+                }
+            )
+        elif isinstance(task_message_content, ToolRequestContent):
+            converted_messages.append(
+                {
+                    "type": "function_call",
+                    "call_id": task_message_content.tool_call_id,
+                    "name": task_message_content.name,
+                    "arguments": json.dumps(task_message_content.arguments),
+                }
+            )
+        elif isinstance(task_message_content, ToolResponseContent):
+            content_str = (
+                task_message_content.content
+                if isinstance(task_message_content.content, str)
+                else json.dumps(task_message_content.content)
+            )
+            converted_messages.append(
+                {
+                    "type": "function_call_output",
+                    "call_id": task_message_content.tool_call_id,
+                    "output": content_str,
+                }
+            )
+        else:
+            raise ValueError(
+                f"Unsupported content type for converting TaskMessage to OpenAI Agents SDK input: {type(task_message.content)}"
+            )
+
+    return converted_messages

agentex/resources/agents.py

@@ -23,6 +23,7 @@ from ..types.agent import Agent
 from .._base_client import make_request_options
 from ..types.agent_rpc_response import AgentRpcResponse, CancelTaskResponse, CreateTaskResponse, SendEventResponse, SendMessageResponse, SendMessageStreamResponse
 from ..types.agent_list_response import AgentListResponse
+from ..types.shared.delete_response import DeleteResponse
 
 __all__ = ["AgentsResource", "AsyncAgentsResource"]
 
@@ -127,7 +128,7 @@ class AgentsResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Agent:
+    ) -> DeleteResponse:
         """
         Delete an agent by its unique ID.
 
@@ -147,7 +148,7 @@ class AgentsResource(SyncAPIResource):
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=Agent,
+            cast_to=DeleteResponse,
         )
 
     def delete_by_name(
@@ -160,7 +161,7 @@ class AgentsResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Agent:
+    ) -> DeleteResponse:
         """
         Delete an agent by its unique name.
 
@@ -180,7 +181,7 @@ class AgentsResource(SyncAPIResource):
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=Agent,
+            cast_to=DeleteResponse,
         )
 
     def retrieve_by_name(
@@ -667,7 +668,7 @@ class AsyncAgentsResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Agent:
+    ) -> DeleteResponse:
         """
         Delete an agent by its unique ID.
 
@@ -687,7 +688,7 @@ class AsyncAgentsResource(AsyncAPIResource):
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=Agent,
+            cast_to=DeleteResponse,
         )
 
     async def delete_by_name(
@@ -700,7 +701,7 @@ class AsyncAgentsResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> Agent:
+    ) -> DeleteResponse:
         """
         Delete an agent by its unique name.
 
@@ -720,7 +721,7 @@ class AsyncAgentsResource(AsyncAPIResource):
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=Agent,
+            cast_to=DeleteResponse,
         )
 
     async def retrieve_by_name(

agentex/resources/messages/messages.py

@@ -192,6 +192,8 @@ class MessagesResource(SyncAPIResource):
         List Messages
 
         Args:
+          task_id: The task ID
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -377,6 +379,8 @@ class AsyncMessagesResource(AsyncAPIResource):
         List Messages
 
         Args:
+          task_id: The task ID
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request