agentex-sdk 0.4.18__py3-none-any.whl → 0.4.20__py3-none-any.whl

agentex/lib/sdk/config/project_config.py

@@ -1,10 +1,10 @@
 import os
 import re
-from pathlib import Path
 from typing import Any, TypeVar
+from pathlib import Path
 
 import yaml
-from jinja2 import BaseLoader, Environment, StrictUndefined, TemplateError
+from jinja2 import BaseLoader, Environment, TemplateError, StrictUndefined
 
 T = TypeVar("T")
 
@@ -35,10 +35,10 @@ def _extract_variables_section(raw_config_str: str) -> str:
 def ProjectConfigLoader(
     config_path: str, model: type[T] | None = None, env_path: str | None = None
 ) -> dict[str, Any] | T:
-    config_path = Path(config_path)
-    env_path = Path(env_path) if env_path else config_path.parent / ".env"
-    env = _load_env(env_path)
-    raw_config_str = _load_file_as_str(config_path)
+    config_path_obj = Path(config_path)
+    env_path_obj = Path(env_path) if env_path else config_path_obj.parent / ".env"
+    env = _load_env(env_path_obj)
+    raw_config_str = _load_file_as_str(config_path_obj)
     raw_config_str = _preprocess_template(raw_config_str)
 
     # Extract and render only the variables section

agentex/lib/sdk/config/validation.py

@@ -5,11 +5,11 @@ This module provides validation functions for agent configurations,
 with clear error messages and best practices enforcement.
 """
 
-from pathlib import Path
 from typing import Any, Dict, List, Optional
+from pathlib import Path
 
-from agentex.lib.sdk.config.environment_config import AgentEnvironmentsConfig, AgentEnvironmentConfig
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.sdk.config.environment_config import AgentEnvironmentConfig, AgentEnvironmentsConfig
 
 logger = make_logger(__name__)
 

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

@@ -1,32 +1,35 @@
+import uuid
 import asyncio
 import inspect
+from typing import Any
 from datetime import datetime
-from collections.abc import AsyncGenerator, Awaitable, Callable
 from contextlib import asynccontextmanager
-from typing import Any
+from collections.abc import Callable, Awaitable, AsyncGenerator
 
 import uvicorn
 from fastapi import FastAPI, Request
-from fastapi.responses import StreamingResponse
 from pydantic import TypeAdapter, ValidationError
+from fastapi.responses import StreamingResponse
+from starlette.middleware.base import BaseHTTPMiddleware
 
-# from agentex.lib.sdk.fastacp.types import BaseACPConfig
-from agentex.lib.environment_variables import EnvironmentVariables, refreshed_environment_variables
 from agentex.lib.types.acp import (
-    PARAMS_MODEL_BY_METHOD,
     RPC_SYNC_METHODS,
-    CancelTaskParams,
-    CreateTaskParams,
+    PARAMS_MODEL_BY_METHOD,
     RPCMethod,
     SendEventParams,
+    CancelTaskParams,
+    CreateTaskParams,
     SendMessageParams,
 )
+from agentex.lib.utils.logging import make_logger, ctx_var_request_id
 from agentex.lib.types.json_rpc import JSONRPCError, JSONRPCRequest, JSONRPCResponse
-from agentex.types.task_message_update import StreamTaskMessageFull, TaskMessageUpdate
-from agentex.types.task_message_content import TaskMessageContent
-from agentex.lib.utils.logging import make_logger
 from agentex.lib.utils.model_utils import BaseModel
 from agentex.lib.utils.registration import register_agent
+
+# from agentex.lib.sdk.fastacp.types import BaseACPConfig
+from agentex.lib.environment_variables import EnvironmentVariables, refreshed_environment_variables
+from agentex.types.task_message_update import TaskMessageUpdate, StreamTaskMessageFull
+from agentex.types.task_message_content import TaskMessageContent
 from agentex.lib.sdk.fastacp.base.constants import (
     FASTACP_HEADER_SKIP_EXACT,
     FASTACP_HEADER_SKIP_PREFIXES,
@@ -38,6 +41,19 @@ logger = make_logger(__name__)
 task_message_update_adapter = TypeAdapter(TaskMessageUpdate)
 
 
+class RequestIDMiddleware(BaseHTTPMiddleware):
+    """Middleware to extract or generate request IDs and add them to logs and response headers"""
+
+    async def dispatch(self, request: Request, call_next):  # type: ignore[override]
+        # Extract request ID from header or generate a new one if there isn't one
+        request_id = request.headers.get("x-request-id") or uuid.uuid4().hex
+        # Store request ID in request state for access in handlers
+        ctx_var_request_id.set(request_id)
+        # Process request
+        response = await call_next(request)
+        return response
+
+
 class BaseACPServer(FastAPI):
     """
     AsyncAgentACP provides RPC-style hooks for agent events and commands asynchronously.
@@ -56,6 +72,8 @@ class BaseACPServer(FastAPI):
         self.post("/api")(self._handle_jsonrpc)
 
         # Method handlers
+        # this just adds a request ID to the request and response headers
+        self.add_middleware(RequestIDMiddleware)
         self._handlers: dict[RPCMethod, Callable] = {}
 
     @classmethod
@@ -72,7 +90,7 @@ class BaseACPServer(FastAPI):
 
     def get_lifespan_function(self):
         @asynccontextmanager
-        async def lifespan_context(app: FastAPI):
+        async def lifespan_context(app: FastAPI):  # noqa: ARG001
             env_vars = EnvironmentVariables.refresh()
             if env_vars.AGENTEX_BASE_URL:
                 await register_agent(env_vars)
@@ -371,4 +389,4 @@ class BaseACPServer(FastAPI):
         """Start the Uvicorn server for async handlers."""
         uvicorn.run(self, host=host, port=port, **kwargs)
 
-    
+    

agentex/lib/sdk/fastacp/fastacp.py

@@ -1,18 +1,18 @@
-import inspect
 import os
+import inspect
+from typing import Literal
 from pathlib import Path
 
-from typing import Any, Literal
-from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
-from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
-from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
-from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
 from agentex.lib.types.fastacp import (
-    AgenticACPConfig,
     BaseACPConfig,
     SyncACPConfig,
+    AgenticACPConfig,
 )
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
+from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
+from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
+from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
 
 # Add new mappings between ACP types and configs here
 # Add new mappings between ACP types and implementations here
@@ -23,6 +23,7 @@ AGENTIC_ACP_IMPLEMENTATIONS: dict[Literal["temporal", "base"], type[BaseACPServe
 
 logger = make_logger(__name__)
 
+
 class FastACP:
     """Factory for creating FastACP instances
 
@@ -33,7 +34,7 @@ class FastACP:
 
     @staticmethod
     # Note: the config is optional and not used right now but is there to be extended in the future
-    def create_sync_acp(config: SyncACPConfig | None = None, **kwargs) -> SyncACP:
+    def create_sync_acp(config: SyncACPConfig | None = None, **kwargs) -> SyncACP:  # noqa: ARG004
         """Create a SyncACP instance"""
         return SyncACP.create(**kwargs)
 
@@ -52,9 +53,9 @@ class FastACP:
             # Extract temporal_address and plugins from config if it's a TemporalACPConfig
             temporal_config = kwargs.copy()
             if hasattr(config, "temporal_address"):
-                temporal_config["temporal_address"] = config.temporal_address
+                temporal_config["temporal_address"] = config.temporal_address  # type: ignore[attr-defined]
             if hasattr(config, "plugins"):
-                temporal_config["plugins"] = config.plugins
+                temporal_config["plugins"] = config.plugins  # type: ignore[attr-defined]
             return implementation_class.create(**temporal_config)
         else:
             return implementation_class.create(**kwargs)
@@ -69,9 +70,7 @@ class FastACP:
 
     @staticmethod
     def create(
-        acp_type: Literal["sync", "agentic"], 
-        config: BaseACPConfig | None = None, 
-        **kwargs
+        acp_type: Literal["sync", "agentic"], config: BaseACPConfig | None = None, **kwargs
     ) -> BaseACPServer | SyncACP | AgenticBaseACP | TemporalACP:
         """Main factory method to create any ACP type
 
@@ -79,10 +78,10 @@ class FastACP:
             acp_type: Type of ACP to create ("sync" or "agentic")
             config: Configuration object. Required for agentic type.
             **kwargs: Additional configuration parameters
-        """ 
+        """
 
         FastACP.locate_build_info_path()
-        
+
         if acp_type == "sync":
             sync_config = config if isinstance(config, SyncACPConfig) else None
             return FastACP.create_sync_acp(sync_config, **kwargs)

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

@@ -1,15 +1,14 @@
 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
+
 from agentex.lib.types.acp import (
+    SendEventParams,
     CancelTaskParams,
     CreateTaskParams,
-    SendEventParams,
 )
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
+from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
 
 logger = make_logger(__name__)
 

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

@@ -1,16 +1,16 @@
-from collections.abc import AsyncGenerator
 from typing import Any, override
+from collections.abc import AsyncGenerator
 
-from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
 from agentex.lib.types.acp import SendMessageParams
+from agentex.lib.utils.logging import make_logger
+from agentex.types.task_message_delta import TextDelta
 from agentex.types.task_message_update import (
-    StreamTaskMessageDelta,
-    StreamTaskMessageFull,
     TaskMessageUpdate,
+    StreamTaskMessageFull,
+    StreamTaskMessageDelta,
 )
-from agentex.types.task_message_delta import TextDelta
-from agentex.types.task_message_content import TaskMessageContent, TextContent
-from agentex.lib.utils.logging import make_logger
+from agentex.types.task_message_content import TextContent, TaskMessageContent
+from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
 
 logger = make_logger(__name__)
 

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

@@ -1,18 +1,18 @@
+from typing import Any, Callable, AsyncGenerator, override
 from contextlib import asynccontextmanager
-from typing import Any, AsyncGenerator, Callable
 
 from fastapi import FastAPI
 
-from agentex.lib.core.clients.temporal.temporal_client import TemporalClient
-from agentex.lib.core.temporal.services.temporal_task_service import TemporalTaskService
-from agentex.lib.environment_variables import EnvironmentVariables
-from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
 from agentex.lib.types.acp import (
+    SendEventParams,
     CancelTaskParams,
     CreateTaskParams,
-    SendEventParams,
 )
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.environment_variables import EnvironmentVariables
+from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
+from agentex.lib.core.clients.temporal.temporal_client import TemporalClient
+from agentex.lib.core.temporal.services.temporal_task_service import TemporalTaskService
 
 logger = make_logger(__name__)
 
@@ -24,7 +24,10 @@ class TemporalACP(BaseACPServer):
     """
 
     def __init__(
-        self, temporal_address: str, temporal_task_service: TemporalTaskService | None = None, plugins: list[Any] | None = None
+        self,
+        temporal_address: str,
+        temporal_task_service: TemporalTaskService | None = None,
+        plugins: list[Any] | None = None,
     ):
         super().__init__()
         self._temporal_task_service = temporal_task_service
@@ -32,6 +35,7 @@ class TemporalACP(BaseACPServer):
         self._plugins = plugins or []
 
     @classmethod
+    @override
     def create(cls, temporal_address: str, plugins: list[Any] | None = None) -> "TemporalACP":
         logger.info("Initializing TemporalACP instance")
 
@@ -41,7 +45,7 @@ class TemporalACP(BaseACPServer):
         logger.info("TemporalACP instance initialized now")
         return temporal_acp
 
-    # This is to override the lifespan function of the base
+    @override
     def get_lifespan_function(self) -> Callable[[FastAPI], AsyncGenerator[None, None]]:
         @asynccontextmanager
         async def lifespan(app: FastAPI):
@@ -52,8 +56,7 @@ class TemporalACP(BaseACPServer):
             if self._temporal_task_service is None:
                 env_vars = EnvironmentVariables.refresh()
                 temporal_client = await TemporalClient.create(
-                    temporal_address=self._temporal_address,
-                    plugins=self._plugins
+                    temporal_address=self._temporal_address, plugins=self._plugins
                 )
                 self._temporal_task_service = TemporalTaskService(
                     temporal_client=temporal_client,
@@ -61,11 +64,12 @@ class TemporalACP(BaseACPServer):
                 )
 
             # Call parent lifespan for agent registration
-            async with super().get_lifespan_function()(app):
+            async with super().get_lifespan_function()(app):  # type: ignore[misc]
                 yield
 
-        return lifespan
+        return lifespan  # type: ignore[return-value]
 
+    @override
     def _setup_handlers(self):
         """Set up the handlers for temporal workflow operations"""
 
@@ -73,17 +77,21 @@ class TemporalACP(BaseACPServer):
         async def handle_task_create(params: CreateTaskParams) -> None:
             """Default create task handler - logs the task"""
             logger.info(f"TemporalACP received task create rpc call for task {params.task.id}")
-            await self._temporal_task_service.submit_task(agent=params.agent, task=params.task, params=params.params)
+            if self._temporal_task_service is not None:
+                await self._temporal_task_service.submit_task(
+                    agent=params.agent, task=params.task, params=params.params
+                )
 
         @self.on_task_event_send
         async def handle_event_send(params: SendEventParams) -> None:
             """Forward messages to running workflows via TaskService"""
             try:
-                await self._temporal_task_service.send_event(
-                    agent=params.agent,
-                    task=params.task,
-                    event=params.event,
-                )
+                if self._temporal_task_service is not None:
+                    await self._temporal_task_service.send_event(
+                        agent=params.agent,
+                        task=params.task,
+                        event=params.event,
+                    )
 
             except Exception as e:
                 logger.error(f"Failed to send message: {e}")
@@ -93,7 +101,8 @@ class TemporalACP(BaseACPServer):
         async def handle_cancel(params: CancelTaskParams) -> None:
             """Cancel running workflows via TaskService"""
             try:
-                await self._temporal_task_service.cancel(task_id=params.task.id)
+                if self._temporal_task_service is not None:
+                    await self._temporal_task_service.cancel(task_id=params.task.id)
             except Exception as e:
                 logger.error(f"Failed to cancel task: {e}")
                 raise

agentex/lib/sdk/fastacp/tests/conftest.py

@@ -1,28 +1,28 @@
-import asyncio
-import socket
 import time
+import socket
+import asyncio
 from typing import Any
 from unittest.mock import AsyncMock, patch
 
 import httpx
 import pytest
-import pytest_asyncio
 import uvicorn
+import pytest_asyncio
 
-from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
-from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
-from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
-from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
+from agentex.types.task import Task
+from agentex.types.agent import Agent
 from agentex.lib.types.acp import (
     CancelTaskParams,
     CreateTaskParams,
     SendMessageParams,
 )
 from agentex.lib.types.json_rpc import JSONRPCRequest
-from agentex.types.agent import Agent
 from agentex.types.task_message import TaskMessageContent
 from agentex.types.task_message_content import TextContent
-from agentex.types.task import Task
+from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
+from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
+from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
+from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
 
 # Configure pytest-asyncio
 pytest_plugins = ("pytest_asyncio",)
@@ -47,7 +47,7 @@ def free_port() -> int:
 def sample_task() -> Task:
     """Fixture that provides a sample Task object"""
     return Task(
-        id="test-task-123", agent_id="test-agent-456", status=TaskStatus.RUNNING
+        id="test-task-123", status="RUNNING"
     )
 
 
@@ -72,6 +72,8 @@ def sample_send_message_params(
             name="test-agent",
             description="test-agent",
             acp_type="sync",
+            created_at="2023-01-01T00:00:00Z",
+            updated_at="2023-01-01T00:00:00Z",
         ),
         task=sample_task,
         content=sample_message_content,
@@ -83,8 +85,8 @@ def sample_send_message_params(
 def sample_cancel_task_params() -> CancelTaskParams:
     """Fixture that provides sample CancelTaskParams"""
     return CancelTaskParams(
-        agent=Agent(id="test-agent-456", name="test-agent", description="test-agent", acp_type="sync"),
-        task=Task(id="test-task-123", agent_id="test-agent-456", status="running"),
+        agent=Agent(id="test-agent-456", name="test-agent", description="test-agent", acp_type="sync", created_at="2023-01-01T00:00:00Z", updated_at="2023-01-01T00:00:00Z"),
+        task=Task(id="test-task-123", status="RUNNING"),
     )
 
 
@@ -92,7 +94,7 @@ def sample_cancel_task_params() -> CancelTaskParams:
 def sample_create_task_params(sample_task: Task) -> CreateTaskParams:
     """Fixture that provides sample CreateTaskParams"""
     return CreateTaskParams(
-        agent=Agent(id="test-agent-456", name="test-agent", description="test-agent", acp_type="sync"),
+        agent=Agent(id="test-agent-456", name="test-agent", description="test-agent", acp_type="sync", created_at="2023-01-01T00:00:00Z", updated_at="2023-01-01T00:00:00Z"),
         task=sample_task,
         params={},
     )
@@ -202,7 +204,7 @@ async def async_sync_acp_server():
     with patch.dict(
         "os.environ", {"AGENTEX_BASE_URL": ""}
     ):  # Disable agent registration
-        server = await SyncACP.create()
+        server = SyncACP.create()
         return server
 
 
@@ -222,7 +224,7 @@ async def async_agentic_base_acp_server():
     with patch.dict(
         "os.environ", {"AGENTEX_BASE_URL": ""}
     ):  # Disable agent registration
-        server = await AgenticBaseACP.create()
+        server = AgenticBaseACP.create()
         return server
 
 
@@ -242,7 +244,7 @@ async def mock_temporal_acp_server():
                 mock_temporal_client.create.return_value = AsyncMock()
                 mock_agentex_client.return_value = AsyncMock()
 
-                server = await TemporalACP.create(temporal_address="localhost:7233")
+                server = TemporalACP.create(temporal_address="localhost:7233")
                 return server
 
 

agentex/lib/sdk/fastacp/tests/run_tests.py

@@ -10,9 +10,9 @@ This script provides various options for running the test suite:
 - Run performance tests
 """
 
+import sys
 import argparse
 import subprocess
-import sys
 from pathlib import Path
 
 

agentex/lib/sdk/fastacp/tests/test_base_acp_server.py

@@ -1,15 +1,16 @@
+# ruff: noqa: ARG001
 import asyncio
 from unittest.mock import patch
 
 import pytest
 from fastapi.testclient import TestClient
 
-from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
 from agentex.lib.types.acp import (
-    CancelTaskParams,
     RPCMethod,
     SendEventParams,
+    CancelTaskParams,
 )
+from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
 
 
 class TestBaseACPServerInitialization:
@@ -21,7 +22,7 @@ class TestBaseACPServerInitialization:
             server = BaseACPServer()
 
             # Check that FastAPI routes are set up
-            routes = [route.path for route in server.routes]
+            routes = [route.path for route in server.routes]  # type: ignore[attr-defined]
             assert "/healthz" in routes
             assert "/api" in routes
 
@@ -141,7 +142,6 @@ class TestJSONRPCEndpointCore:
         data = response.json()
         assert data["jsonrpc"] == "2.0"
         assert data["id"] == "test-1"
-        print("DATA", data)
         # Should return immediate acknowledgment
         assert data["result"]["status"] == "processing"
 

agentex/lib/sdk/fastacp/tests/test_fastacp_factory.py

@@ -3,17 +3,17 @@ from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
-from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
-from agentex.lib.sdk.fastacp.fastacp import FastACP
-from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
-from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
-from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
 from agentex.lib.types.fastacp import (
-    AgenticACPConfig,
-    AgenticBaseACPConfig,
     SyncACPConfig,
+    AgenticACPConfig,
     TemporalACPConfig,
+    AgenticBaseACPConfig,
 )
+from agentex.lib.sdk.fastacp.fastacp import FastACP
+from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
+from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
+from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
+from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
 
 
 class TestFastACPInitialization:
@@ -212,7 +212,7 @@ class TestConfigurationValidation:
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
             # This should raise TypeError since config is required parameter
             with pytest.raises(TypeError):
-                FastACP.create_agentic_acp()
+                FastACP.create_agentic_acp()  # type: ignore[call-arg]
 
     def test_invalid_acp_type_string(self):
         """Test that invalid ACP type string raises ValueError"""

agentex/lib/sdk/fastacp/tests/test_integration.py

@@ -1,18 +1,19 @@
+# ruff: noqa: ARG001
 import asyncio
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import httpx
 import pytest
 
-from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
-from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
-from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
 from agentex.lib.types.acp import (
-    CancelTaskParams,
-    CreateTaskParams,
     RPCMethod,
     SendEventParams,
+    CancelTaskParams,
+    CreateTaskParams,
 )
+from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
+from agentex.lib.sdk.fastacp.impl.temporal_acp import TemporalACP
+from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
 
 
 class TestImplementationBehavior:
@@ -48,7 +49,7 @@ class TestImplementationBehavior:
                 mock_temporal_instance.temporal_client = MagicMock()
                 mock_create.return_value = mock_temporal_instance
 
-                temporal_acp = await TemporalACP.create()
+                temporal_acp = TemporalACP.create(temporal_address="localhost:7233")
 
                 assert temporal_acp == mock_temporal_instance
                 assert hasattr(temporal_acp, "temporal_client")
@@ -67,8 +68,8 @@ class TestRealWorldScenarios:
             messages_received.append(
                 {
                     "task_id": params.task.id,
-                    "message_content": params.message.content,
-                    "author": params.message.author,
+                    "message_content": params.message.content,  # type: ignore[attr-defined]
+                    "author": params.message.author,  # type: ignore[attr-defined]
                 }
             )
             return {"processed": True}
@@ -127,7 +128,7 @@ class TestRealWorldScenarios:
 
         @agentic_base_acp.on_task_cancel
         async def cancel_handler(params: CancelTaskParams):
-            task_events.append(("cancelled", params.task_id))
+            task_events.append(("cancelled", params.task_id))  # type: ignore[attr-defined]
 
         runner = test_server_runner(agentic_base_acp, free_port)
         await runner.start()
@@ -209,7 +210,7 @@ class TestErrorRecovery:
         @sync_acp.on_task_event_send
         async def unreliable_handler(params: SendEventParams):
             nonlocal failure_count, success_count
-            if "fail" in params.message.content:
+            if "fail" in params.message.content:  # type: ignore[attr-defined]
                 failure_count += 1
                 raise RuntimeError("Simulated handler failure")
             else:
@@ -326,7 +327,7 @@ class TestSpecialCases:
         @sync_acp.on_task_event_send
         async def tracking_handler(params: SendEventParams):
             nonlocal notifications_received, requests_received
-            if "notification" in params.message.content:
+            if "notification" in params.message.content:  # type: ignore[attr-defined]
                 notifications_received += 1
             else:
                 requests_received += 1
@@ -397,7 +398,7 @@ class TestSpecialCases:
         @sync_acp.on_task_event_send
         async def unicode_handler(params: SendEventParams):
             nonlocal received_message
-            received_message = params.message.content
+            received_message = params.message.content  # type: ignore[attr-defined]
             return {"unicode_handled": True}
 
         runner = test_server_runner(sync_acp, free_port)
@@ -458,9 +459,9 @@ class TestImplementationIsolation:
                 return {"agentic": True}
 
             # Create test parameters
-            message_params = SendEventParams(
+            message_params = SendEventParams(  # type: ignore[call-arg]
                 task={"id": "isolation-test-task", "agent_id": "test-agent", "status": "RUNNING"},
-                message={"type": "text", "author": "user", "content": "Isolation test"},
+                event={"type": "text", "author": "user", "content": "Isolation test"},  # type: ignore[misc]
             )
 
             # Execute sync handler

agentex/lib/sdk/state_machine/__init__.py

@@ -1,5 +1,5 @@
-from .noop_workflow import NoOpWorkflow
 from .state import State
+from .noop_workflow import NoOpWorkflow
 from .state_machine import StateMachine
 from .state_workflow import StateWorkflow
 

agentex/lib/sdk/state_machine/noop_workflow.py

@@ -1,8 +1,9 @@
+from typing import TYPE_CHECKING, override
+
 from pydantic import BaseModel
 
-from agentex.lib.sdk.state_machine.state_workflow import StateWorkflow
 from agentex.lib.utils.logging import make_logger
-from typing import TYPE_CHECKING
+from agentex.lib.sdk.state_machine.state_workflow import StateWorkflow
 
 if TYPE_CHECKING:
     from agentex.lib.sdk.state_machine import StateMachine
@@ -15,7 +16,8 @@ class NoOpWorkflow(StateWorkflow):
     Workflow that does nothing. This is commonly used as a terminal state.
     """
 
+    @override
     async def execute(
         self, state_machine: "StateMachine", state_machine_data: BaseModel | None = None
     ) -> str:
-        pass
+        return state_machine.get_current_state()  # Stay in current state