agentex-sdk 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

agentex/lib/environment_variables.py

@@ -61,7 +61,7 @@ class EnvironmentVariables(BaseModel):
     AGENT_DESCRIPTION: str | None = None
     AGENT_ID: str | None = None
     AGENT_API_KEY: str | None = None
-    ACP_TYPE: str | None = "agentic"
+    ACP_TYPE: str | None = "async"
     AGENT_INPUT_TYPE: str | None = None
     # ACP Configuration
     ACP_URL: str

agentex/lib/sdk/config/agent_config.py

@@ -18,7 +18,7 @@ class AgentConfig(BaseModel):
         description="The name of the agent.",
         pattern=r"^[a-z0-9-]+$",
     )
-    acp_type: Literal["sync", "agentic"] = Field(..., description="The type of agent.")
+    acp_type: Literal["sync", "async", "agentic"] = Field(..., description="The type of agent.")
     agent_input_type: Literal["text", "json"] | None = Field(
         default=None,
         description="The type of input the agent accepts."

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

@@ -299,7 +299,7 @@ class BaseACPServer(FastAPI):
     Define all possible decorators to be overriden and implemented by each ACP implementation
     Then the users can override the default handlers by implementing their own handlers
 
-    ACP Type: Agentic
+    ACP Type: Async
     Decorators:
     - on_task_create
     - on_task_event_send
@@ -310,14 +310,14 @@ class BaseACPServer(FastAPI):
     - on_message_send
     """
 
-    # Type: Agentic
+    # Type: Async
     def on_task_create(self, fn: Callable[[CreateTaskParams], Awaitable[Any]]):
         """Handle task/init method"""
         wrapped = self._wrap_handler(fn)
         self._handlers[RPCMethod.TASK_CREATE] = wrapped
         return fn
 
-    # Type: Agentic
+    # Type: Async
     def on_task_event_send(self, fn: Callable[[SendEventParams], Awaitable[Any]]):
         """Handle event/send method"""
 
@@ -335,7 +335,7 @@ class BaseACPServer(FastAPI):
         self._handlers[RPCMethod.EVENT_SEND] = wrapped
         return fn
 
-    # Type: Agentic
+    # Type: Async
     def on_task_cancel(self, fn: Callable[[CancelTaskParams], Awaitable[Any]]):
         """Handle task/cancel method"""
         wrapped = self._wrap_handler(fn)

agentex/lib/sdk/fastacp/fastacp.py

@@ -4,23 +4,25 @@ import os
 import inspect
 from typing import Literal
 from pathlib import Path
+from typing_extensions import deprecated
 
 from agentex.lib.types.fastacp import (
     BaseACPConfig,
     SyncACPConfig,
+    AsyncACPConfig,
     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.impl.async_base_acp import AsyncBaseACP
 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
 AGENTIC_ACP_IMPLEMENTATIONS: dict[Literal["temporal", "base"], type[BaseACPServer]] = {
     "temporal": TemporalACP,
-    "base": AgenticBaseACP,
+    "base": AsyncBaseACP,
 }
 
 logger = make_logger(__name__)
@@ -29,9 +31,10 @@ logger = make_logger(__name__)
 class FastACP:
     """Factory for creating FastACP instances
 
-    Supports two main ACP types:
+    Supports three main ACP types:
     - "sync": Simple synchronous ACP implementation
-    - "agentic": Advanced ACP with sub-types "base" or "temporal" (requires config)
+    - "async": Advanced ACP with sub-types "base" or "temporal" (requires config)
+    - "agentic": (Deprecated, use "async") Identical to "async" 
     """
 
     @staticmethod
@@ -41,11 +44,11 @@ class FastACP:
         return SyncACP.create(**kwargs)
 
     @staticmethod
-    def create_agentic_acp(config: AgenticACPConfig, **kwargs) -> BaseACPServer:
-        """Create an agentic ACP instance (base or temporal)
+    def create_async_acp(config: AsyncACPConfig, **kwargs) -> BaseACPServer:
+        """Create an async ACP instance (base or temporal)
 
         Args:
-            config: AgenticACPConfig with type="base" or type="temporal"
+            config: AsyncACPConfig with type="base" or type="temporal"
             **kwargs: Additional configuration parameters
         """
         # Get implementation class
@@ -64,6 +67,17 @@ class FastACP:
         else:
             return implementation_class.create(**kwargs)
 
+    @staticmethod
+    @deprecated("Use create_async_acp instead")
+    def create_agentic_acp(config: AgenticACPConfig, **kwargs) -> BaseACPServer:
+        """Create an async ACP instance (base or temporal)
+
+        Args:
+            config: AsyncACPConfig with type="base" or type="temporal"
+            **kwargs: Additional configuration parameters
+        """
+        return FastACP.create_async_acp(config, **kwargs)
+
     @staticmethod
     def locate_build_info_path() -> None:
         """If a build-info.json file is present, set the BUILD_INFO_PATH environment variable"""
@@ -74,13 +88,13 @@ class FastACP:
 
     @staticmethod
     def create(
-        acp_type: Literal["sync", "agentic"], config: BaseACPConfig | None = None, **kwargs
-    ) -> BaseACPServer | SyncACP | AgenticBaseACP | TemporalACP:
+        acp_type: Literal["sync", "async", "agentic"], config: BaseACPConfig | None = None, **kwargs
+    ) -> BaseACPServer | SyncACP | AsyncBaseACP | TemporalACP:
         """Main factory method to create any ACP type
 
         Args:
-            acp_type: Type of ACP to create ("sync" or "agentic")
-            config: Configuration object. Required for agentic type.
+            acp_type: Type of ACP to create ("sync", "async", or "agentic")
+            config: Configuration object. Required for async/agentic type.
             **kwargs: Additional configuration parameters
         """
 
@@ -89,9 +103,9 @@ class FastACP:
         if acp_type == "sync":
             sync_config = config if isinstance(config, SyncACPConfig) else None
             return FastACP.create_sync_acp(sync_config, **kwargs)
-        elif acp_type == "agentic":
+        elif acp_type == "async" or acp_type == "agentic":
             if config is None:
-                config = AgenticACPConfig(type="base")
-            if not isinstance(config, AgenticACPConfig):
-                raise ValueError("AgenticACPConfig is required for agentic ACP type")
-            return FastACP.create_agentic_acp(config, **kwargs)
+                config = AsyncACPConfig(type="base")
+            if not isinstance(config, AsyncACPConfig):
+                raise ValueError("AsyncACPConfig is required for async/agentic ACP type")
+            return FastACP.create_async_acp(config, **kwargs)

agentex/lib/sdk/fastacp/impl/{agentic_base_acp.py → async_base_acp.py}

@@ -13,9 +13,9 @@ from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
 logger = make_logger(__name__)
 
 
-class AgenticBaseACP(BaseACPServer):
+class AsyncBaseACP(BaseACPServer):
     """
-    AgenticBaseACP implementation - a synchronous ACP that provides basic functionality
+    AsyncBaseACP implementation - a synchronous ACP that provides basic functionality
     without any special async orchestration like Temporal.
 
     This implementation provides simple synchronous processing of tasks
@@ -29,7 +29,7 @@ class AgenticBaseACP(BaseACPServer):
 
     @classmethod
     @override
-    def create(cls, **kwargs: Any) -> "AgenticBaseACP":
+    def create(cls, **kwargs: Any) -> "AsyncBaseACP":
         """Create and initialize SyncACP instance
 
         Args:
@@ -38,9 +38,9 @@ class AgenticBaseACP(BaseACPServer):
         Returns:
             Initialized SyncACP instance
         """
-        logger.info("Initializing AgenticBaseACP instance")
+        logger.info("Initializing AsyncBaseACP instance")
         instance = cls()
-        logger.info("AgenticBaseACP instance initialized with default handlers")
+        logger.info("AsyncBaseACP instance initialized with default handlers")
         return instance
 
     @override
@@ -50,13 +50,13 @@ class AgenticBaseACP(BaseACPServer):
         @self.on_task_create
         async def handle_create_task(params: CreateTaskParams) -> None:  # type: ignore[unused-function]
             """Default create task handler - logs the task"""
-            logger.info(f"AgenticBaseACP creating task {params.task.id}")
+            logger.info(f"AsyncBaseACP creating task {params.task.id}")
 
         @self.on_task_event_send
         async def handle_event_send(params: SendEventParams) -> None:  # type: ignore[unused-function]
             """Default event handler - logs the event"""
             logger.info(
-                f"AgenticBaseACP received event for task {params.task.id}: {params.event.id},"
+                f"AsyncBaseACP received event for task {params.task.id}: {params.event.id},"
                 f"content: {params.event.content}"
             )
             # TODO: Implement event handling logic here
@@ -70,4 +70,6 @@ class AgenticBaseACP(BaseACPServer):
         @self.on_task_cancel
         async def handle_cancel(params: CancelTaskParams) -> None:  # type: ignore[unused-function]
             """Default cancel handler - logs the cancellation"""
-            logger.info(f"AgenticBaseACP canceling task {params.task.id}")
+            logger.info(f"AsyncBaseACP canceling task {params.task.id}")
+
+AgenticBaseACP = AsyncBaseACP

agentex/lib/sdk/fastacp/tests/README.md

@@ -1,6 +1,6 @@
 # BaseACPServer Test Suite
 
-This directory contains comprehensive tests for the `BaseACPServer` and its implementations (`SyncACP`, `AgenticBaseACP`, and `TemporalACP`).
+This directory contains comprehensive tests for the `BaseACPServer` and its implementations (`SyncACP`, `AsyncBaseACP`, and `TemporalACP`).
 
 ## Test Structure
 
@@ -29,7 +29,7 @@ The test suite is organized into several categories:
 
 ### 4. Implementation Tests (`test_implementations.py`)
 - **TestSyncACP**: SyncACP-specific functionality
-- **TestAgenticBaseACP**: AgenticBaseACP-specific functionality
+- **TestAsyncBaseACP**: AsyncBaseACP-specific functionality
 - **TestTemporalACP**: TemporalACP-specific functionality
 - **TestImplementationComparison**: Differences between implementations
 - **TestImplementationErrorHandling**: Implementation-specific error handling
@@ -165,7 +165,7 @@ Test components working together:
 ### Implementation Tests
 Test specific ACP implementations:
 - SyncACP behavior
-- AgenticBaseACP send_event functionality
+- AsyncBaseACP send_event functionality
 - TemporalACP workflow integration
 - Implementation differences
 

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

@@ -23,8 +23,8 @@ from agentex.types.task_message import TaskMessageContent
 from agentex.types.task_message_content import TextContent
 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.async_base_acp import AsyncBaseACP
 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",)
@@ -216,17 +216,17 @@ def agentic_base_acp_server():
     with patch.dict(
         "os.environ", {"AGENTEX_BASE_URL": ""}
     ):  # Disable agent registration
-        server = AgenticBaseACP()
+        server = AsyncBaseACP()
         return server
 
 
 @pytest_asyncio.fixture
 async def async_agentic_base_acp_server():
-    """Fixture that provides an AgenticBaseACP instance for async tests"""
+    """Fixture that provides an AsyncBaseACP instance for async tests"""
     with patch.dict(
         "os.environ", {"AGENTEX_BASE_URL": ""}
     ):  # Disable agent registration
-        server = AgenticBaseACP.create()
+        server = AsyncBaseACP.create()
         return server
 
 

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

@@ -5,15 +5,15 @@ import pytest
 
 from agentex.lib.types.fastacp import (
     SyncACPConfig,
-    AgenticACPConfig,
+    AsyncACPConfig,
     TemporalACPConfig,
-    AgenticBaseACPConfig,
+    AsyncBaseACPConfig,
 )
 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.impl.async_base_acp import AsyncBaseACP
 from agentex.lib.sdk.fastacp.base.base_acp_server import BaseACPServer
-from agentex.lib.sdk.fastacp.impl.agentic_base_acp import AgenticBaseACP
 
 
 class TestFastACPInitialization:
@@ -23,7 +23,7 @@ class TestFastACPInitialization:
         """Test that FastACP class exists and is properly structured"""
         assert hasattr(FastACP, "create")
         assert hasattr(FastACP, "create_sync_acp")
-        assert hasattr(FastACP, "create_agentic_acp")
+        assert hasattr(FastACP, "create_async_acp")
 
 
 class TestSyncACPCreation:
@@ -82,62 +82,62 @@ class TestSyncACPCreation:
             assert isinstance(sync_acp, SyncACP)
 
 
-class TestAgenticBaseACPCreation:
-    """Test AgenticBaseACP creation through factory"""
+class TestAsyncBaseACPCreation:
+    """Test AsyncBaseACP creation through factory"""
 
     @pytest.mark.asyncio
-    async def test_create_agentic_base_acp_direct_method(self):
-        """Test creating AgenticBaseACP using direct method"""
+    async def test_create_async_base_acp_direct_method(self):
+        """Test creating AsyncBaseACP using direct method"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            config = AgenticACPConfig(type="base")
-            agentic_acp = FastACP.create_agentic_acp(config=config)
+            config = AsyncACPConfig(type="base")
+            async_acp = FastACP.create_async_acp(config=config)
 
-            assert isinstance(agentic_acp, AgenticBaseACP)
-            assert isinstance(agentic_acp, BaseACPServer)
+            assert isinstance(async_acp, AsyncBaseACP)
+            assert isinstance(async_acp, BaseACPServer)
 
     @pytest.mark.asyncio
-    async def test_create_agentic_base_acp_with_specific_config(self):
-        """Test creating AgenticBaseACP with AgenticBaseACPConfig"""
+    async def test_create_async_base_acp_with_specific_config(self):
+        """Test creating AsyncBaseACP with AsyncBaseACPConfig"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            config = AgenticBaseACPConfig(type="base")
-            agentic_acp = FastACP.create_agentic_acp(config=config)
+            config = AsyncBaseACPConfig(type="base")
+            async_acp = FastACP.create_async_acp(config=config)
 
-            assert isinstance(agentic_acp, AgenticBaseACP)
+            assert isinstance(async_acp, AsyncBaseACP)
 
     @pytest.mark.asyncio
-    async def test_create_agentic_base_acp_via_generic_create(self):
-        """Test creating AgenticBaseACP via generic create method"""
+    async def test_create_async_base_acp_via_generic_create(self):
+        """Test creating AsyncBaseACP via generic create method"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            config = AgenticACPConfig(type="base")
-            agentic_acp = FastACP.create("agentic", config=config)
+            config = AsyncACPConfig(type="base")
+            async_acp = FastACP.create("async", config=config)
 
-            assert isinstance(agentic_acp, AgenticBaseACP)
+            assert isinstance(async_acp, AsyncBaseACP)
 
     @pytest.mark.asyncio
-    async def test_create_agentic_base_acp_with_enum(self):
-        """Test creating AgenticBaseACP using ACPType enum"""
+    async def test_create_async_base_acp_with_enum(self):
+        """Test creating AsyncBaseACP using ACPType enum"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            config = AgenticACPConfig(type="base")
-            agentic_acp = FastACP.create("agentic", config=config)
+            config = AsyncACPConfig(type="base")
+            async_acp = FastACP.create("async", config=config)
 
-            assert isinstance(agentic_acp, AgenticBaseACP)
+            assert isinstance(async_acp, AsyncBaseACP)
 
 
-class TestAgenticTemporalACPCreation:
-    """Test AgenticTemporalACP (TemporalACP) creation through factory"""
+class TestAsyncTemporalACPCreation:
+    """Test AsyncTemporalACP (TemporalACP) creation through factory"""
 
     @pytest.mark.asyncio
     async def test_create_temporal_acp_direct_method(self):
         """Test creating TemporalACP using direct method"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            config = AgenticACPConfig(type="temporal")
+            config = AsyncACPConfig(type="temporal")
 
             # Mock the TemporalACP.create method since it requires temporal dependencies
             with patch.object(TemporalACP, "create", new_callable=AsyncMock) as mock_create:
                 mock_temporal_instance = MagicMock(spec=TemporalACP)
                 mock_create.return_value = mock_temporal_instance
 
-                temporal_acp = FastACP.create_agentic_acp(config=config)
+                temporal_acp = FastACP.create_async_acp(config=config)
 
                 assert temporal_acp == mock_temporal_instance
                 mock_create.assert_called_once()
@@ -152,7 +152,7 @@ class TestAgenticTemporalACPCreation:
                 mock_temporal_instance = MagicMock(spec=TemporalACP)
                 mock_create.return_value = mock_temporal_instance
 
-                temporal_acp = FastACP.create_agentic_acp(config=config)
+                temporal_acp = FastACP.create_async_acp(config=config)
 
                 assert temporal_acp == mock_temporal_instance
                 # Verify temporal_address was passed
@@ -162,13 +162,13 @@ class TestAgenticTemporalACPCreation:
     async def test_create_temporal_acp_via_generic_create(self):
         """Test creating TemporalACP via generic create method"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            config = AgenticACPConfig(type="temporal")
+            config = AsyncACPConfig(type="temporal")
 
             with patch.object(TemporalACP, "create", new_callable=AsyncMock) as mock_create:
                 mock_temporal_instance = MagicMock(spec=TemporalACP)
                 mock_create.return_value = mock_temporal_instance
 
-                temporal_acp = FastACP.create("agentic", config=config)
+                temporal_acp = FastACP.create("async", config=config)
 
                 assert temporal_acp == mock_temporal_instance
 
@@ -182,7 +182,7 @@ class TestAgenticTemporalACPCreation:
                 mock_temporal_instance = MagicMock(spec=TemporalACP)
                 mock_create.return_value = mock_temporal_instance
 
-                FastACP.create_agentic_acp(config=config)
+                FastACP.create_async_acp(config=config)
 
                 mock_create.assert_called_once_with(temporal_address="custom-temporal:9999")
 
@@ -191,28 +191,28 @@ class TestConfigurationValidation:
     """Test configuration validation and error handling"""
 
     @pytest.mark.asyncio
-    async def test_agentic_requires_config(self):
-        """Test that agentic ACP creation requires configuration"""
+    async def test_async_requires_config(self):
+        """Test that async ACP creation requires configuration"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            with pytest.raises(ValueError, match="AgenticACPConfig is required"):
-                FastACP.create("agentic")
+            with pytest.raises(ValueError, match="AsyncACPConfig is required"):
+                FastACP.create("async")
 
     @pytest.mark.asyncio
-    async def test_agentic_requires_correct_config_type(self):
-        """Test that agentic ACP creation requires AgenticACPConfig type"""
+    async def test_async_requires_correct_config_type(self):
+        """Test that async ACP creation requires AsyncACPConfig type"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
             sync_config = SyncACPConfig()
 
-            with pytest.raises(ValueError, match="AgenticACPConfig is required"):
-                FastACP.create("agentic", config=sync_config)
+            with pytest.raises(ValueError, match="AsyncACPConfig is required"):
+                FastACP.create("async", config=sync_config)
 
     @pytest.mark.asyncio
-    async def test_agentic_direct_method_requires_config(self):
-        """Test that direct agentic method requires configuration"""
+    async def test_async_direct_method_requires_config(self):
+        """Test that direct async method requires configuration"""
         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()  # type: ignore[call-arg]
+                FastACP.create_async_acp()  # type: ignore[call-arg]
 
     def test_invalid_acp_type_string(self):
         """Test that invalid ACP type string raises ValueError"""
@@ -220,12 +220,12 @@ class TestConfigurationValidation:
             with pytest.raises(ValueError):
                 asyncio.run(FastACP.create("invalid_type"))
 
-    def test_invalid_agentic_type_in_config(self):
-        """Test that invalid agentic type in config raises ValueError"""
+    def test_invalid_async_type_in_config(self):
+        """Test that invalid async type in config raises ValueError"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
             # This should raise ValueError during config creation
             with pytest.raises(ValueError):
-                AgenticACPConfig(type="invalid_agentic_type")
+                AsyncACPConfig(type="invalid_async_type")
 
     @pytest.mark.asyncio
     async def test_unsupported_acp_type_enum(self):
@@ -234,6 +234,7 @@ class TestConfigurationValidation:
             # Create a mock enum value that's not supported
             with patch("agentex.sdk.fastacp.fastacp.ACPType") as mock_enum:
                 mock_enum.SYNC = "sync"
+                mock_enum.ASYNC = "async"
                 mock_enum.AGENTIC = "agentic"
                 unsupported_type = "unsupported"
 
@@ -253,26 +254,26 @@ class TestErrorHandling:
                     FastACP.create_sync_acp()
 
     @pytest.mark.asyncio
-    async def test_agentic_acp_creation_failure(self):
-        """Test handling of AgenticACP creation failure"""
+    async def test_async_acp_creation_failure(self):
+        """Test handling of AsyncACP creation failure"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            config = AgenticACPConfig(type="base")
+            config = AsyncACPConfig(type="base")
 
-            with patch.object(AgenticBaseACP, "create", side_effect=Exception("Creation failed")):
+            with patch.object(AsyncBaseACP, "create", side_effect=Exception("Creation failed")):
                 with pytest.raises(Exception, match="Creation failed"):
-                    FastACP.create_agentic_acp(config=config)
+                    FastACP.create_async_acp(config=config)
 
     @pytest.mark.asyncio
     async def test_temporal_acp_creation_failure(self):
         """Test handling of TemporalACP creation failure"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
-            config = AgenticACPConfig(type="temporal")
+            config = AsyncACPConfig(type="temporal")
 
             with patch.object(
                 TemporalACP, "create", side_effect=Exception("Temporal connection failed")
             ):
                 with pytest.raises(Exception, match="Temporal connection failed"):
-                    FastACP.create_agentic_acp(config=config)
+                    FastACP.create_async_acp(config=config)
 
 
 class TestIntegrationScenarios:
@@ -286,34 +287,59 @@ class TestIntegrationScenarios:
             sync_acp = FastACP.create("sync")
             assert isinstance(sync_acp, SyncACP)
 
-            # Create AgenticBaseACP
-            base_config = AgenticACPConfig(type="base")
-            agentic_base = FastACP.create("agentic", config=base_config)
-            assert isinstance(agentic_base, AgenticBaseACP)
+            # Create AsyncBaseACP
+            base_config = AsyncACPConfig(type="base")
+            async_base = FastACP.create("async", config=base_config)
+            assert isinstance(async_base, AsyncBaseACP)
 
             # Create TemporalACP (mocked)
-            temporal_config = AgenticACPConfig(type="temporal")
+            temporal_config = AsyncACPConfig(type="temporal")
             with patch.object(TemporalACP, "create", new_callable=AsyncMock) as mock_create:
                 mock_temporal_instance = MagicMock(spec=TemporalACP)
                 mock_create.return_value = mock_temporal_instance
 
-                temporal_acp = FastACP.create("agentic", config=temporal_config)
+                temporal_acp = FastACP.create("async", config=temporal_config)
                 assert temporal_acp == mock_temporal_instance
 
+    @pytest.mark.asyncio
+    async def test_async_type_backwards_compatibility(self):
+        """Test that 'async' type works the same as 'async' for backwards compatibility"""
+        with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
+            # Test async with base config
+            base_config = AsyncACPConfig(type="base")
+            async_base = FastACP.create("async", config=base_config)
+            assert isinstance(async_base, AsyncBaseACP)
+
+            # Test async with temporal config (mocked)
+            temporal_config = AsyncACPConfig(type="temporal")
+            with patch.object(TemporalACP, "create", new_callable=AsyncMock) as mock_create:
+                mock_temporal_instance = MagicMock(spec=TemporalACP)
+                mock_create.return_value = mock_temporal_instance
+
+                temporal_acp = FastACP.create("async", config=temporal_config)
+                assert temporal_acp == mock_temporal_instance
+
+            # Test that async requires config
+            with pytest.raises(ValueError, match="AsyncACPConfig is required"):
+                sync_config = SyncACPConfig()
+                FastACP.create("async", config=sync_config)
+
     @pytest.mark.asyncio
     async def test_configuration_driven_creation(self):
         """Test configuration-driven ACP creation"""
         with patch.dict("os.environ", {"AGENTEX_BASE_URL": ""}):
             configs = [
                 ("sync", None),
-                ("agentic", AgenticACPConfig(type="base")),
-                ("agentic", TemporalACPConfig(type="temporal", temporal_address="localhost:7233")),
+                ("async", AsyncACPConfig(type="base")),
+                ("async", AsyncACPConfig(type="base")),
+                ("async", TemporalACPConfig(type="temporal", temporal_address="localhost:7233")),
+                ("async", TemporalACPConfig(type="temporal", temporal_address="localhost:7233")),
             ]
 
             created_acps = []
 
             for acp_type, config in configs:
-                if acp_type == "agentic" and config.type == "temporal":
+                if acp_type in ("async", "async") and config and config.type == "temporal":
                     # Mock temporal creation
                     with patch.object(TemporalACP, "create", new_callable=AsyncMock) as mock_create:
                         mock_temporal_instance = MagicMock(spec=TemporalACP)
@@ -325,10 +351,11 @@ class TestIntegrationScenarios:
                     acp = FastACP.create(acp_type, config=config)
                     created_acps.append(acp)
 
-            assert len(created_acps) == 3
+            assert len(created_acps) == 5
             assert isinstance(created_acps[0], SyncACP)
-            assert isinstance(created_acps[1], AgenticBaseACP)
-            # Third one is mocked TemporalACP
+            assert isinstance(created_acps[1], AsyncBaseACP)
+            assert isinstance(created_acps[2], AsyncBaseACP)
+            # Fourth and fifth ones are mocked TemporalACP
 
     @pytest.mark.asyncio
     async def test_factory_with_custom_kwargs(self):
@@ -338,7 +365,7 @@ class TestIntegrationScenarios:
             sync_acp = FastACP.create_sync_acp(custom_param="test")
             assert isinstance(sync_acp, SyncACP)
 
-            # Test agentic base with kwargs
-            config = AgenticACPConfig(type="base")
-            agentic_acp = FastACP.create_agentic_acp(config=config, custom_param="test")
-            assert isinstance(agentic_acp, AgenticBaseACP)
+            # Test async base with kwargs
+            config = AsyncACPConfig(type="base")
+            async_acp = FastACP.create_async_acp(config=config, custom_param="test")
+            assert isinstance(async_acp, AsyncBaseACP)